lutaml-model 0.7.2 → 0.7.5

data/lib/lutaml/model/xml/document.rb

@@ -8,11 +8,12 @@ module Lutaml
   module Model
     module Xml
       class Document
-        attr_reader :root, :encoding
+        attr_reader :root, :encoding, :register
 
-        def initialize(root, encoding = nil)
+        def initialize(root, encoding = nil, register: nil)
           @root = root
           @encoding = encoding
+          @register = setup_register(register)
         end
 
         def self.parse(xml, _options = {})
@@ -79,7 +80,7 @@ module Lutaml
           options[:mixed_content] = rule.mixed_content
           options[:tag_name] = rule.name
 
-          options[:mapper_class] = attribute&.type if attribute
+          options[:mapper_class] = attribute&.type(register) if attribute
           options[:set_namespace] = set_namespace?(rule)
 
           options
@@ -107,7 +108,7 @@ module Lutaml
             result["elements"] ||= Lutaml::Model::MappingHash.new
             result["elements"].assign_or_append_value(
               self.class.namespaced_name_of(child),
-              parse_element(child, attr&.type || klass, format),
+              parse_element(child, attr&.type(register) || klass, format),
             )
           end
 
@@ -127,9 +128,9 @@ module Lutaml
                 prefix: attr.namespace_prefix,
                 schema_location: attr.value,
               }
+            else
+              result[attr.namespaced_name] = attr.value
             end
-
-            result[attr.namespaced_name] = attr.value
           end
 
           result
@@ -148,17 +149,16 @@ module Lutaml
           rule = options[:rule]
 
           if rule.custom_methods[:to]
-            options[:mapper_class].new.send(rule.custom_methods[:to], element,
-                                            xml.parent, xml)
+            options[:mapper_class].new.send(rule.custom_methods[:to], element, xml.parent, xml)
             return
           end
 
           # Only transform when recursion is not called
-          if !attribute.collection? || value.is_a?(Array)
+          if !attribute.collection? || attribute.collection_instance?(value)
             value = ExportTransformer.call(value, rule, attribute)
           end
 
-          if value.is_a?(Array) && !Utils.empty_collection?(value)
+          if attribute.collection_instance?(value) && !Utils.empty_collection?(value)
             value.each do |item|
               add_to_xml(xml, element, prefix, item, options)
             end
@@ -170,7 +170,7 @@ module Lutaml
 
           value = rule.render_value_for(value)
 
-          if value && (attribute&.type&.<= Lutaml::Model::Serialize)
+          if value && (attribute&.type(register)&.<= Lutaml::Model::Serialize)
             handle_nested_elements(
               xml,
               value,
@@ -195,10 +195,10 @@ module Lutaml
 
         def add_value(xml, value, attribute, cdata: false)
           if !value.nil?
-            serialized_value = attribute.serialize(value, :xml)
+            serialized_value = attribute.serialize(value, :xml, register)
             if attribute.raw?
               xml.add_xml_fragment(xml, value)
-            elsif attribute.type == Lutaml::Model::Type::Hash
+            elsif attribute.type(register) == Lutaml::Model::Type::Hash
               serialized_value.each do |key, val|
                 xml.create_and_add_element(key) do |element|
                   element.text(val)
@@ -242,7 +242,7 @@ module Lutaml
 
                 next if !element_rule.render?(value, element)
 
-                value = [value] if attribute_def.collection? && !value.is_a?(Array)
+                value = attribute_def.build_collection(value) if attribute_def.collection? && !attribute_def.collection_instance?(value)
               end
 
               add_to_xml(
@@ -264,8 +264,12 @@ module Lutaml
           return unless content_rule
 
           if content_rule.custom_methods[:to]
-            mapper_class.new.send(content_rule.custom_methods[:to], element,
-                                  xml.parent, xml)
+            mapper_class.new.send(
+              content_rule.custom_methods[:to],
+              element,
+              xml.parent,
+              xml,
+            )
           else
             text = content_rule.serialize(element)
             text = text.join if text.is_a?(Array)
@@ -320,9 +324,10 @@ module Lutaml
             processed[klass][mapping_rule.name] = true
 
             type = if mapping_rule.delegate
-                     attributes[mapping_rule.delegate].type.attributes[mapping_rule.to].type
+                     attributes[mapping_rule.delegate].type(register)
+                       .attributes[mapping_rule.to].type(register)
                    else
-                     attributes[mapping_rule.to]&.type
+                     attributes[mapping_rule.to]&.type(register)
                    end
 
             next unless type
@@ -363,7 +368,7 @@ module Lutaml
 
             value = mapping_rule.to_value_for(element)
             attr = attribute_definition_for(element, mapping_rule, mapper_class: options[:mapper_class])
-            value = attr.serialize(value, :xml) if attr
+            value = attr.serialize(value, :xml, register) if attr
 
             value = ExportTransformer.call(value, mapping_rule, attr)
 
@@ -433,6 +438,19 @@ module Lutaml
 
         private
 
+        def setup_register(register)
+          return register if register.is_a?(Symbol)
+
+          return_register = if register.is_a?(Lutaml::Model::Register)
+                              register.id
+                            elsif @root.respond_to?(:register)
+                              @root.register
+                            elsif @root.instance_variable_defined?(:@register)
+                              @root.instance_variable_get(:@register)
+                            end
+          return_register || Lutaml::Model::Config.default_register
+        end
+
         def determine_mapper_class(element, options)
           if options[:mapper_class] && element.is_a?(options[:mapper_class])
             element.class

data/lib/lutaml/model/xml/mapping.rb

@@ -17,7 +17,8 @@ module Lutaml
                     :namespace_prefix,
                     :mixed_content,
                     :ordered,
-                    :element_sequence
+                    :element_sequence,
+                    :mappings_imported
 
         def initialize
           super
@@ -29,12 +30,19 @@ module Lutaml
           @raw_mapping = nil
           @mixed_content = false
           @format = :xml
+          @mappings_imported = true
+          @finalized = false
         end
 
         def finalize(mapper_class)
           if !root_element && !no_root?
             root(mapper_class.model.to_s)
           end
+          @finalized = true
+        end
+
+        def finalized?
+          @finalized
         end
 
         alias mixed_content? mixed_content
@@ -73,6 +81,10 @@ module Lutaml
           @namespace_prefix = prefix
         end
 
+        def map_instances(to:)
+          map_element(to, to: to)
+        end
+
         # rubocop:disable Metrics/ParameterLists
         def map_element(
           name,
@@ -244,12 +256,11 @@ module Lutaml
         alias map_all_content map_all
 
         def sequence(&block)
-          @element_sequence << Sequence.new(self).tap do |s|
-            s.instance_eval(&block)
-          end
+          @element_sequence << Sequence.new(self).tap { |s| s.instance_eval(&block) }
         end
 
         def import_model_mappings(model)
+          return import_mappings_later(model) if model_importable?(model)
           raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
 
           mappings = model.mappings_for(:xml)
@@ -258,6 +269,10 @@ module Lutaml
           (@element_sequence << mappings.element_sequence).flatten!
         end
 
+        def set_mappings_imported(value)
+          @mappings_imported = value
+        end
+
         def validate!(key, to, with, render_nil, render_empty, type: nil)
           validate_raw_mappings!(type)
           validate_to_and_with_arguments!(key, to, with)
@@ -316,24 +331,49 @@ module Lutaml
           @raw_mapping
         end
 
-        def mappings
+        def mappings(register_id = nil)
+          ensure_mappings_imported!(register_id) if finalized?
           elements + attributes + [content_mapping, raw_mapping].compact
         end
 
-        def element(name)
-          elements.detect do |rule|
-            name == rule.to
+        def ensure_mappings_imported!(register_id = nil)
+          return if @mappings_imported
+
+          importable_mappings.each do |model|
+            import_model_mappings(
+              register(register_id).get_class_without_register(model),
+            )
+          end
+
+          sequence_importable_mappings.each do |sequence, models|
+            models.each do |model|
+              sequence.import_model_mappings(
+                register(register_id).get_class_without_register(model),
+              )
+            end
           end
+
+          @mappings_imported = true
+        end
+
+        def importable_mappings
+          @importable_mappings ||= []
+        end
+
+        def sequence_importable_mappings
+          @sequence_importable_mappings ||= Hash.new { |h, k| h[k] = [] }
+        end
+
+        def element(name)
+          elements.detect { |rule| name == rule.to }
         end
 
         def attribute(name)
-          attributes.detect do |rule|
-            name == rule.to
-          end
+          attributes.detect { |rule| name == rule.to }
         end
 
-        def find_by_name(name)
-          if ["text", "#cdata-section"].include?(name.to_s)
+        def find_by_name(name, type: "Text")
+          if ["text", "#cdata-section"].include?(name.to_s) && type == "Text"
             content_mapping
           else
             mappings.detect do |rule|
@@ -342,6 +382,10 @@ module Lutaml
           end
         end
 
+        def find_by_to(to)
+          mappings.detect { |rule| rule.to.to_s == to.to_s }
+        end
+
         def mapping_attributes_hash
           @attributes
         end
@@ -378,6 +422,7 @@ module Lutaml
               value = instance_variable_get(var_name)
               xml_mapping.instance_variable_set(var_name, Utils.deep_dup(value))
             end
+            xml_mapping.instance_variable_set(:@finalized, true)
           end
         end
 
@@ -404,6 +449,22 @@ module Lutaml
 
           new_mappings
         end
+
+        private
+
+        def register(register_id = nil)
+          register_id ||= Lutaml::Model::Config.default_register
+          Lutaml::Model::GlobalRegister.lookup(register_id)
+        end
+
+        def model_importable?(model)
+          model.is_a?(Symbol) || model.is_a?(String)
+        end
+
+        def import_mappings_later(model)
+          importable_mappings << model.to_sym
+          @mappings_imported = false
+        end
       end
     end
   end

data/lib/lutaml/model/xml/mapping_rule.rb

@@ -4,7 +4,11 @@ module Lutaml
   module Model
     module Xml
       class MappingRule < MappingRule
-        attr_reader :namespace, :prefix, :mixed_content, :default_namespace, :cdata
+        attr_reader :namespace,
+                    :prefix,
+                    :mixed_content,
+                    :default_namespace,
+                    :cdata
 
         def initialize(
           name,
@@ -80,6 +84,10 @@ module Lutaml
           cdata ? "#cdata-section" : "text"
         end
 
+        def castable?
+          !raw_mapping? && !content_mapping? && !custom_methods[:from]
+        end
+
         def mixed_content?
           !!@mixed_content
         end
@@ -103,7 +111,7 @@ module Lutaml
 
         def namespaced_name(parent_namespace = nil, name = self.name)
           if name.to_s == "lang"
-            "#{prefix}:#{name}"
+            Utils.blank?(prefix) ? name.to_s : "#{prefix}:#{name}"
           elsif namespace_set? || @attribute
             [namespace, name].compact.join(":")
           elsif default_namespace

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

@@ -72,10 +72,11 @@ module Lutaml
             content = []
 
             element.element_order.each do |object|
-              index_hash[object.name] ||= -1
-              curr_index = index_hash[object.name] += 1
+              object_key = "#{object.name}-#{object.type}"
+              index_hash[object_key] ||= -1
+              curr_index = index_hash[object_key] += 1
 
-              element_rule = xml_mapping.find_by_name(object.name)
+              element_rule = xml_mapping.find_by_name(object.name, type: object.type)
               next if element_rule.nil?
 
               attribute_def = attribute_definition_for(element, element_rule,
@@ -153,6 +154,7 @@ module Lutaml
             parse_all_children(node, root_node: root_node || self,
                                      default_namespace: default_namespace),
             node.text,
+            name: node.name,
             parent_document: root_node,
             namespace_prefix: node.namespace&.prefix,
             default_namespace: default_namespace

data/lib/lutaml/model/xml/oga/element.rb

@@ -19,11 +19,14 @@ module Lutaml
                    when Moxml::Text
                      node.content
                    end
+
+            name = OgaAdapter.name_of(node)
             super(
-              OgaAdapter.name_of(node),
+              name,
               Hash(attributes),
               Array(children),
               text,
+              name: name,
               parent_document: parent,
               namespace_prefix: namespace_name,
             )

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

@@ -126,10 +126,11 @@ module Lutaml
             content = []
 
             element.element_order.each do |object|
-              index_hash[object.name] ||= -1
-              curr_index = index_hash[object.name] += 1
+              object_key = "#{object.name}-#{object.type}"
+              index_hash[object_key] ||= -1
+              curr_index = index_hash[object_key] += 1
 
-              element_rule = xml_mapping.find_by_name(object.name)
+              element_rule = xml_mapping.find_by_name(object.name, type: object.type)
               next if element_rule.nil?
 
               attribute_def = attribute_definition_for(element, element_rule,

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

@@ -59,10 +59,11 @@ module Lutaml
             content = []
 
             element.element_order.each do |object|
-              index_hash[object.name] ||= -1
-              curr_index = index_hash[object.name] += 1
+              object_key = "#{object.name}-#{object.type}"
+              index_hash[object_key] ||= -1
+              curr_index = index_hash[object_key] += 1
 
-              element_rule = xml_mapping.find_by_name(object.name)
+              element_rule = xml_mapping.find_by_name(object.name, type: object.type)
               next if element_rule.nil?
 
               attribute_def = attribute_definition_for(element, element_rule,
@@ -103,11 +104,11 @@ module Lutaml
         def initialize(node, root_node: nil)
           case node
           when String
-            super("text", {}, [], node, parent_document: root_node)
+            super("text", {}, [], node, parent_document: root_node, name: "text")
           when Ox::Comment
-            super("comment", {}, [], node.value, parent_document: root_node)
+            super("comment", {}, [], node.value, parent_document: root_node, name: "comment")
           when Ox::CData
-            super("#cdata-section", {}, [], node.value, parent_document: root_node)
+            super("#cdata-section", {}, [], node.value, parent_document: root_node, name: "#cdata-section")
           else
             namespace_attributes(node.attributes).each do |(name, value)|
               if root_node
@@ -135,16 +136,29 @@ module Lutaml
               )
             end
 
+            prefix, name = separate_name_and_prefix(node)
+
             super(
               node,
               attributes,
               parse_children(node, root_node: root_node || self),
               node.text,
               parent_document: root_node,
+              name: name,
+              namespace_prefix: prefix,
             )
           end
         end
 
+        def separate_name_and_prefix(node)
+          name = node.name.to_s
+
+          return [nil, name] unless name.include?(":")
+
+          prefix, _, name = name.partition(":")
+          [prefix, name]
+        end
+
         def to_xml
           return text if text?
 

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

@@ -19,12 +19,13 @@ module Lutaml
           attributes = {},
           children = [],
           text = nil,
+          name: nil,
           parent_document: nil,
           namespace_prefix: nil,
           default_namespace: nil
         )
-          @name = extract_name(node)
-          @namespace_prefix = namespace_prefix || extract_namespace_prefix(node)
+          @name = name
+          @namespace_prefix = namespace_prefix
           @attributes = attributes
           @children = children
           @text = text
@@ -92,32 +93,6 @@ module Lutaml
           namespaces[nil] || @parent_document&.namespaces&.dig(nil)
         end
 
-        def extract_name(node)
-          name = name_from_node(node)
-
-          n = name.split(":")
-          return name if n.length <= 1
-
-          n[1..].join(":")
-        end
-
-        def extract_namespace_prefix(node)
-          name = name_from_node(node)
-
-          n = name.to_s.split(":")
-          return if n.length <= 1
-
-          n.first
-        end
-
-        def name_from_node(node)
-          if node.is_a?(String)
-            node
-          else
-            node.name.to_s
-          end
-        end
-
         def order
           children.map do |child|
             type = child.text? ? "Text" : "Element"

data/lib/lutaml/model/xml.rb

@@ -6,7 +6,7 @@ module Lutaml
       def self.detect_xml_adapter
         return :nokogiri if Object.const_defined?(:Nokogiri)
         return :ox if Object.const_defined?(:Ox)
-        return :opal if Object.const_defined?(:Opal)
+        return :oga if Object.const_defined?(:Oga)
 
         nil
       end

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

@@ -8,7 +8,7 @@ module Lutaml
   module Model
     module XmlAdapter
       class Element < ::Lutaml::Model::Xml::Element
-        Logger.warn_future_deprication(
+        Logger.warn_future_deprecation(
           old: "Lutaml::Model::XmlAdapter::Element",
           replacement: "Lutaml::Model::Xml::Element",
         )

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

@@ -5,7 +5,7 @@ module Lutaml
   module Model
     module XmlAdapter
       class NokogiriAdapter < ::Lutaml::Model::Xml::NokogiriAdapter
-        Logger.warn_future_deprication(
+        Logger.warn_future_deprecation(
           old: "Lutaml::Model::XmlAdapter::NokogiriAdapter",
           replacement: "Lutaml::Model::Xml::NokogiriAdapter",
         )

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

@@ -11,7 +11,7 @@ module Lutaml
   module Model
     module XmlAdapter
       class OgaAdapter < ::Lutaml::Model::Xml::OgaAdapter
-        Logger.warn_future_deprication(
+        Logger.warn_future_deprecation(
           old: "Lutaml::Model::XmlAdapter::OgaAdapter",
           replacement: "Lutaml::Model::Xml::OgaAdapter",
         )

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

@@ -8,7 +8,7 @@ module Lutaml
   module Model
     module XmlAdapter
       class OxAdapter < ::Lutaml::Model::Xml::OxAdapter
-        Logger.warn_future_deprication(
+        Logger.warn_future_deprecation(
           old: "Lutaml::Model::XmlAdapter::OxAdapter",
           replacement: "Lutaml::Model::Xml::OxAdapter",
         )

data/lib/lutaml/model/yamls/document.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Yamls
+      class Document
+        def initialize(yamls = [], register: nil)
+          @yamls = yamls
+          @register = register || Lutaml::Model::Config.default_register
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/yamls/mapping.rb

@@ -0,0 +1,19 @@
+require_relative "../mapping/key_value_mapping"
+
+module Lutaml
+  module Model
+    module Yamls
+      class Mapping < Lutaml::Model::KeyValueMapping
+        def initialize
+          super(:yaml)
+        end
+
+        def deep_dup
+          self.class.new.tap do |new_mapping|
+            new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/yamls/mapping_rule.rb

@@ -0,0 +1,9 @@
+require_relative "../mapping/key_value_mapping_rule"
+
+module Lutaml
+  module Model
+    module Yamls
+      class MappingRule < Lutaml::Model::KeyValueMappingRule; end
+    end
+  end
+end

data/lib/lutaml/model/yamls/standard_adapter.rb

@@ -0,0 +1,34 @@
+require "yaml"
+require_relative "document"
+
+module Lutaml
+  module Model
+    module Yamls
+      class StandardAdapter < Document
+        FORMAT_SYMBOL = :yaml
+
+        def self.parse(yamls, _options = {})
+          results = []
+
+          yamls.split(/^---\n/).each do |yaml|
+            next if yaml.strip.empty?
+
+            begin
+              results << YAML.safe_load(yaml, aliases: true)
+            rescue Psych::SyntaxError => e
+              warn "Skipping invalid yaml: #{e.message}"
+            end
+          end
+
+          results
+        end
+
+        def to_yamls(*_args)
+          @yamls.map do |yaml|
+            YAML.dump(yaml).strip
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/yamls/transform.rb

@@ -0,0 +1,19 @@
+module Lutaml
+  module Model
+    module Yamls
+      class Transform < Lutaml::Model::KeyValueTransform
+        def data_to_model(data, format, options = {})
+          mappings = defined_mappings_for(:yamls) || mappings_for(:yaml)
+
+          super(data, format, options.merge(mappings: mappings))
+        end
+
+        def model_to_data(instance, format, options = {})
+          mappings = defined_mappings_for(:yamls) || mappings_for(:yaml)
+
+          super(instance, format, options.merge(mappings: mappings))
+        end
+      end
+    end
+  end
+end