lutaml-model 0.2.1 → 0.3.1

data/lib/lutaml/model/xml_adapter.rb

@@ -1,10 +1,13 @@
 # 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
 
@@ -33,8 +36,113 @@ module Lutaml
           declaration
         end
 
-        # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/MethodLength
+        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)
 
@@ -52,8 +160,19 @@ module Lutaml
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
-        # rubocop:enable Metrics/MethodLength
+
+        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
@@ -70,7 +189,6 @@ module Lutaml
                     :namespace_prefix,
                     :parent_document
 
-        # rubocop:disable Metrics/ParameterLists
         def initialize(
           name,
           attributes = {},
@@ -86,10 +204,9 @@ module Lutaml
           @text = text
           @parent_document = parent_document
         end
-        # rubocop:enable Metrics/ParameterLists
 
         def name
-          if namespace_prefix && namespaces[namespace_prefix]
+          if namespace_prefix
             "#{namespace_prefix}:#{@name}"
           else
             @name
@@ -144,6 +261,12 @@ module Lutaml
 
           n.first
         end
+
+        def order
+          children.each_with_object([]) do |child, arr|
+            arr << child.unprefixed_name
+          end
+        end
       end
 
       class Attribute
@@ -155,6 +278,14 @@ module Lutaml
           @namespace = namespace
           @namespace_prefix = namespace_prefix
         end
+
+        def unprefixed_name
+          if namespace_prefix
+            name.split(":").last
+          else
+            name
+          end
+        end
       end
     end
   end

data/lib/lutaml/model/xml_mapping.rb

@@ -4,16 +4,23 @@ require_relative "xml_mapping_rule"
 module Lutaml
   module Model
     class XmlMapping
-      attr_reader :root_element, :namespace_uri, :namespace_prefix
+      attr_reader :root_element,
+                  :namespace_uri,
+                  :namespace_prefix,
+                  :mixed_content
 
       def initialize
         @elements = []
         @attributes = []
         @content_mapping = nil
+        @mixed_content = false
       end
 
-      def root(name)
+      alias mixed_content? mixed_content
+
+      def root(name, mixed: false)
         @root_element = name
+        @mixed_content = mixed
       end
 
       def prefixed_root
@@ -36,8 +43,10 @@ module Lutaml
         render_nil: false,
         with: {},
         delegate: nil,
-        namespace: nil,
-        prefix: nil
+        namespace: (namespace_set = false
+                    nil),
+        prefix: nil,
+        mixed: false
       )
         @elements << XmlMappingRule.new(
           name,
@@ -47,6 +56,8 @@ module Lutaml
           delegate: delegate,
           namespace: namespace,
           prefix: prefix,
+          mixed_content: mixed,
+          namespace_set: namespace_set != false,
         )
       end
 
@@ -56,7 +67,8 @@ module Lutaml
         render_nil: false,
         with: {},
         delegate: nil,
-        namespace: nil,
+        namespace: (namespace_set = false
+                    nil),
         prefix: nil
       )
         @attributes << XmlMappingRule.new(
@@ -67,17 +79,25 @@ module Lutaml
           delegate: delegate,
           namespace: namespace,
           prefix: prefix,
+          namespace_set: namespace_set != false,
         )
       end
       # rubocop:enable Metrics/ParameterLists
 
-      def map_content(to:, render_nil: false, with: {}, delegate: nil)
+      def map_content(
+        to:,
+        render_nil: false,
+        with: {},
+        delegate: nil,
+        mixed: false
+      )
         @content_mapping = XmlMappingRule.new(
           nil,
           to: to,
           render_nil: render_nil,
           with: with,
           delegate: delegate,
+          mixed_content: mixed,
         )
       end
 
@@ -108,6 +128,16 @@ module Lutaml
           name == rule.to
         end
       end
+
+      def find_by_name(name)
+        if name.to_s == "text"
+          content_mapping
+        else
+          mappings.detect do |rule|
+            rule.name == name.to_s || rule.name == name.to_sym
+          end
+        end
+      end
     end
   end
 end

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -6,8 +6,6 @@ module Lutaml
     class XmlMappingRule < MappingRule
       attr_reader :namespace, :prefix
 
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/ParameterLists
       def initialize(
         name,
         to:,
@@ -15,14 +13,18 @@ module Lutaml
         with: {},
         delegate: nil,
         namespace: nil,
-        prefix: nil
+        prefix: nil,
+        mixed_content: false,
+        namespace_set: false
       )
         super(
           name,
           to: to,
           render_nil: render_nil,
           with: with,
-          delegate: delegate
+          delegate: delegate,
+          mixed_content: mixed_content,
+          namespace_set: namespace_set
         )
 
         @namespace = if namespace.to_s == "inherit"
@@ -33,8 +35,6 @@ module Lutaml
                      end
         @prefix = prefix
       end
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Metrics/ParameterLists
     end
   end
 end

data/lib/lutaml/model/yaml_adapter.rb

@@ -4,9 +4,17 @@ require "yaml"
 module Lutaml
   module Model
     module YamlAdapter
-      module Standard
-        def self.to_yaml(model, *args)
-          YAML.dump(model.hash_representation(:yaml), *args)
+      class Standard
+        def initialize(attributes)
+          @attributes = attributes
+        end
+
+        def to_yaml(options = {})
+          YAML.dump(@attributes, options)
+        end
+
+        def self.to_yaml(attributes, *args)
+          new(attributes).to_yaml(*args)
         end
 
         def self.from_yaml(yaml, klass)

data/lib/lutaml/model.rb

@@ -12,9 +12,16 @@ require_relative "model/json_adapter"
 require_relative "model/yaml_adapter"
 require_relative "model/xml_adapter"
 require_relative "model/toml_adapter"
+require_relative "model/error"
 
 module Lutaml
   module Model
+    # Error for passing incorrect model type
+    #
+    # @api private
+    class IncorrectModelError < StandardError
+    end
+
     class BaseModel < Serializable
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-10 00:00:00.000000000 Z
+date: 2024-08-13 00:00:00.000000000 Z
 dependencies: []
 description: 'LutaML creating data models in Ruby
 
@@ -24,6 +24,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".rubocop_todo.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - README.adoc
@@ -33,11 +34,14 @@ files:
 - lib/lutaml/model.rb
 - lib/lutaml/model/attribute.rb
 - lib/lutaml/model/config.rb
+- lib/lutaml/model/error.rb
+- lib/lutaml/model/error/invalid_value_error.rb
 - lib/lutaml/model/json_adapter.rb
 - lib/lutaml/model/json_adapter/multi_json.rb
 - lib/lutaml/model/json_adapter/standard.rb
 - lib/lutaml/model/key_value_mapping.rb
 - lib/lutaml/model/key_value_mapping_rule.rb
+- lib/lutaml/model/mapping_hash.rb
 - lib/lutaml/model/mapping_rule.rb
 - lib/lutaml/model/schema.rb
 - lib/lutaml/model/schema/json_schema.rb