lutaml-model 0.1.0 → 0.2.1

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

@@ -12,36 +12,83 @@ module Lutaml
           new(root)
         end
 
-        def initialize(root)
-          @root = root
-        end
-
         def to_h
-          { @root.name => parse_element(@root) }
+          # { @root.name => parse_element(@root) }
+          parse_element(@root)
         end
 
         def to_xml(options = {})
           builder = Ox::Builder.new
           build_element(builder, @root, options)
-          xml_data = Ox.dump(builder)
+          # xml_data = Ox.dump(builder)
+          xml_data = builder.to_s
           options[:declaration] ? declaration(options) + xml_data : xml_data
         end
 
         private
 
-        def build_element(builder, element, options = {})
-          attributes = build_attributes(element.attributes)
-          builder.element(element.name, attributes) do
-            element.children.each do |child|
-              build_element(builder, child, options)
+        # rubocop:disable Layout/LineLength
+        # rubocop:disable Layout/MethodLength
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def build_element(builder, element, _options = {})
+          return element.to_xml(builder) if element.is_a?(Lutaml::Model::XmlAdapter::OxElement)
+
+          xml_mapping = element.class.mappings_for(:xml)
+          return xml unless xml_mapping
+
+          attributes = build_attributes(element, xml_mapping)
+
+          builder.element(xml_mapping.root_element, attributes) do |el|
+            xml_mapping.elements.each do |element_rule|
+              if element_rule.delegate
+                attribute_def = element.send(element_rule.delegate).class.attributes[element_rule.to]
+                value = element.send(element_rule.delegate).send(element_rule.to)
+              else
+                attribute_def = element.class.attributes[element_rule.to]
+                value = element.send(element_rule.to)
+              end
+
+              val = if attribute_def.collection?
+                      value
+                    elsif value || element_rule.render_nil?
+                      [value]
+                    else
+                      []
+                    end
+
+              val.each do |v|
+                if attribute_def&.type&.<= Lutaml::Model::Serialize
+                  handle_nested_elements(el, element_rule, v)
+                else
+                  builder.element(element_rule.name) do |el|
+                    el.text(attribute_def.type.serialize(v)) if v
+                  end
+                end
+              end
             end
-            builder.text(element.text) if element.text
+            # if element.children.any?
+            #   element.children.each do |child|
+            #     build_element(el, child, options)
+            #   end
+            # elsif element.text
+            #   el.text(element.text)
+            # end
           end
         end
+        # rubocop:enable Layout/LineLength
+        # rubocop:enable Layout/MethodLength
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/PerceivedComplexity
 
-        def build_attributes(attributes)
-          attributes.each_with_object({}) do |(name, attr), hash|
-            hash[name] = attr.value
+        def handle_nested_elements(builder, _element_rule, value)
+          case value
+          when Array
+            value.each { |val| build_element(builder, val) }
+          else
+            build_element(builder, value)
           end
         end
 
@@ -49,6 +96,7 @@ module Lutaml
           result = { "_text" => element.text }
           element.nodes.each do |child|
             next if child.is_a?(Ox::Raw) || child.is_a?(Ox::Comment)
+
             result[child.name] ||= []
             result[child.name] << parse_element(child)
           end
@@ -57,17 +105,81 @@ module Lutaml
       end
 
       class OxElement < Element
-        def initialize(node)
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Layout/LineLength
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def initialize(node, root_node: nil)
           attributes = node.attributes.each_with_object({}) do |(name, value), hash|
-            hash[name.to_s] = Attribute.new(name.to_s, value)
+            if attribute_is_namespace?(name)
+              if root_node
+                root_node.add_namespace(Lutaml::Model::XmlNamespace.new(value,
+                                                                        name))
+              else
+                add_namespace(Lutaml::Model::XmlNamespace.new(value, name))
+              end
+            else
+              namespace_prefix = name.to_s.split(":").first
+              if root_node && (n = root_node.namespaces[namespace_prefix])
+                namespace = n.uri
+                prefix = n.prefix
+              end
+
+              hash[name.to_s] = Attribute.new(
+                name.to_s,
+                value,
+                namespace: namespace,
+                namespace_prefix: prefix,
+              )
+            end
+          end
+
+          super(
+            node.name.to_s,
+            attributes,
+            parse_children(node, root_node: root_node || self),
+            node.text,
+            parent_document: root_node
+          )
+        end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Layout/LineLength
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        def to_xml(builder = nil)
+          builder ||= Ox::Builder.new
+          attrs = build_attributes(self)
+
+          builder.element(name, attrs) do |el|
+            if children.any?
+              children.each { |child| child.to_xml(el) }
+            elsif text
+              el.text(text)
+            end
           end
-          super(node.name.to_s, attributes, parse_children(node), node.text)
+        end
+
+        def build_attributes(node)
+          attrs = node.attributes.transform_values(&:value)
+
+          node.own_namespaces.each_value do |namespace|
+            attrs[namespace.attr_name] = namespace.uri
+          end
+
+          attrs
         end
 
         private
 
-        def parse_children(node)
-          node.nodes.select { |child| child.is_a?(Ox::Element) }.map { |child| OxElement.new(child) }
+        def parse_children(node, root_node: nil)
+          node.nodes.select do |child|
+            child.is_a?(Ox::Element)
+          end.map do |child|
+            OxElement.new(child, root_node: root_node)
+          end
         end
       end
     end

data/lib/lutaml/model/xml_adapter.rb

@@ -1,5 +1,7 @@
 # lib/lutaml/model/xml_adapter.rb
 
+require_relative "xml_namespace"
+
 module Lutaml
   module Model
     module XmlAdapter
@@ -19,30 +21,129 @@ module Lutaml
         end
 
         def declaration(options)
-          version = options[:declaration].is_a?(String) ? options[:declaration] : "1.0"
-          encoding = options[:encoding].is_a?(String) ? options[:encoding] : (options[:encoding] ? "UTF-8" : nil)
+          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
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        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
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/MethodLength
+
+        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 :name, :attributes, :children, :text, :namespace, :namespace_prefix
+        attr_reader :attributes,
+                    :children,
+                    :text,
+                    :namespace_prefix,
+                    :parent_document
 
-        def initialize(name, attributes = {}, children = [], text = nil, namespace: nil, namespace_prefix: nil)
-          @name = name
-          @attributes = attributes.map { |k, v| Attribute.new(k, v) }
+        # rubocop:disable Metrics/ParameterLists
+        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
-          @namespace = namespace
-          @namespace_prefix = namespace_prefix
+          @parent_document = parent_document
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        def name
+          if namespace_prefix && namespaces[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
       end
 
       class Attribute

data/lib/lutaml/model/xml_mapping.rb

@@ -16,21 +16,69 @@ module Lutaml
         @root_element = name
       end
 
+      def prefixed_root
+        if namespace_uri && namespace_prefix
+          "#{namespace_prefix}:#{root_element}"
+        else
+          root_element
+        end
+      end
+
       def namespace(uri, prefix = nil)
         @namespace_uri = uri
         @namespace_prefix = prefix
       end
 
-      def map_element(name, to:, render_nil: false, with: {}, delegate: nil, namespace: nil, prefix: nil)
-        @elements << XmlMappingRule.new(name, to: to, render_nil: render_nil, with: with, delegate: delegate, namespace: namespace, prefix: prefix)
+      # rubocop:disable Metrics/ParameterLists
+      def map_element(
+        name,
+        to:,
+        render_nil: false,
+        with: {},
+        delegate: nil,
+        namespace: nil,
+        prefix: nil
+      )
+        @elements << XmlMappingRule.new(
+          name,
+          to: to,
+          render_nil: render_nil,
+          with: with,
+          delegate: delegate,
+          namespace: namespace,
+          prefix: prefix,
+        )
       end
 
-      def map_attribute(name, to:, render_nil: false, with: {}, delegate: nil, namespace: nil, prefix: nil)
-        @attributes << XmlMappingRule.new(name, to: to, render_nil: render_nil, with: with, delegate: delegate, namespace: namespace, prefix: prefix)
+      def map_attribute(
+        name,
+        to:,
+        render_nil: false,
+        with: {},
+        delegate: nil,
+        namespace: nil,
+        prefix: nil
+      )
+        @attributes << XmlMappingRule.new(
+          name,
+          to: to,
+          render_nil: render_nil,
+          with: with,
+          delegate: delegate,
+          namespace: namespace,
+          prefix: prefix,
+        )
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def map_content(to:, render_nil: false, with: {}, delegate: nil)
-        @content_mapping = XmlMappingRule.new(nil, to: to, render_nil: render_nil, with: with, delegate: delegate)
+        @content_mapping = XmlMappingRule.new(
+          nil,
+          to: to,
+          render_nil: render_nil,
+          with: with,
+          delegate: delegate,
+        )
       end
 
       def elements

data/lib/lutaml/model/xml_mapping_rule.rb

@@ -6,11 +6,35 @@ module Lutaml
     class XmlMappingRule < MappingRule
       attr_reader :namespace, :prefix
 
-      def initialize(name, to:, render_nil: false, with: {}, delegate: nil, namespace: nil, prefix: nil)
-        super(name, to: to, render_nil: render_nil, with: with, delegate: delegate)
-        @namespace = namespace
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(
+        name,
+        to:,
+        render_nil: false,
+        with: {},
+        delegate: nil,
+        namespace: nil,
+        prefix: nil
+      )
+        super(
+          name,
+          to: to,
+          render_nil: render_nil,
+          with: with,
+          delegate: delegate
+        )
+
+        @namespace = if namespace.to_s == "inherit"
+                       # we are using inherit_namespace in xml builder by
+                       # default so no need to do anything here.
+                     else
+                       namespace
+                     end
         @prefix = prefix
       end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/ParameterLists
     end
   end
 end

data/lib/lutaml/model/xml_namespace.rb

@@ -0,0 +1,47 @@
+# frozen_striing_literal: true
+
+module Lutaml
+  module Model
+    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

data/lib/lutaml/model/yaml_adapter.rb

@@ -16,7 +16,9 @@ module Lutaml
         end
 
         def self.parse(yaml)
-          YAML.safe_load(yaml, permitted_classes: [Date, Time, DateTime, Symbol, BigDecimal, Hash, Array])
+          YAML.safe_load(yaml,
+                         permitted_classes: [Date, Time, DateTime, Symbol,
+                                             BigDecimal, Hash, Array])
         end
       end
     end

data/lutaml-model.gemspec

@@ -18,33 +18,20 @@ Gem::Specification.new do |spec|
 
   spec.bindir = "bin"
   spec.require_paths = ["lib"]
-  spec.files = `git ls-files`.split("\n")
-  spec.test_files = `git ls-files -- {spec}/*`.split("\n")
   spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
 
   # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  # The `git ls-files -z` loads the files in the
+  # RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
       f.match(%r{^(test|spec|features)/})
     end
   end
-  spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
 
   # spec.add_runtime_dependency "expressir"
   # spec.add_runtime_dependency "metanorma-cli"
   # spec.add_runtime_dependency "shale"
   # spec.add_runtime_dependency "thor", ">= 0.20"
-  spec.add_development_dependency "multi_json"
-  spec.add_development_dependency "tomlib"
-  spec.add_development_dependency "toml-rb"
-  spec.add_development_dependency "oga"
-  spec.add_development_dependency "ox"
-  spec.add_development_dependency "nokogiri"
-  spec.add_development_dependency "rubocop"
-  spec.add_development_dependency "rubocop-performance"
-  spec.add_development_dependency "rubocop-rails"
-  spec.add_development_dependency "equivalent-xml"
 end