moxml 0.1.3 → 0.1.6

data/lib/moxml/adapter/ox.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
 
 require_relative "base"
+# before ox so that all Ox classes inherit the monkey-patched Node
+require_relative "../../ox/node"
 require "ox"
+require_relative "customized_ox/text"
+require_relative "customized_ox/attribute"
+require_relative "customized_ox/namespace"
 
 module Moxml
   module Adapter
@@ -30,8 +35,9 @@ module Moxml
           DocumentBuilder.new(Context.new(:ox)).build(native_doc)
         end
 
-        def create_document
-          ::Ox::Document.new
+        def create_document(native_doc = nil)
+          attrs = native_doc&.attributes || {}
+          ::Ox::Document.new(**attrs)
         end
 
         def create_native_element(name)
@@ -52,63 +58,94 @@ module Moxml
           ::Ox::Comment.new(content)
         end
 
+        def create_native_doctype(name, external_id, system_id)
+          ::Ox::DocType.new(
+            "#{name} PUBLIC \"#{external_id}\" \"#{system_id}\""
+          )
+        end
+
         def create_native_processing_instruction(target, content)
-          inst = ::Ox::Instruction.new(target)
-          inst.value = content
+          inst = ::Ox::Instruct.new(target)
+          set_processing_instruction_content(inst, content)
           inst
         end
 
-        # TODO: compare  to create_native_declaration
-        def create_native_declaration2(version, encoding, standalone)
+        def create_native_declaration(version, encoding, standalone)
           inst = ::Ox::Instruct.new("xml")
-          inst.value = build_declaration_attrs(version, encoding, standalone)
+          set_attribute(inst, "version", version)
+          set_attribute(inst, "encoding", encoding)
+          set_attribute(inst, "standalone", standalone)
           inst
         end
 
-        def create_native_declaration(version, encoding, standalone)
-          doc = ::Ox::Document.new
-          doc.version = version
-          doc.encoding = encoding
-          doc.standalone = standalone
-          doc
+        def declaration_attribute(declaration, attr_name)
+          get_attribute_value(declaration, attr_name)
+        end
+
+        def set_declaration_attribute(declaration, attr_name, value)
+          set_attribute(declaration, attr_name, value)
         end
 
         def create_native_namespace(element, prefix, uri)
-          element.attributes ||= {}
-          attr_name = prefix ? "xmlns:#{prefix}" : "xmlns"
-          element.attributes[attr_name] = uri
-          [prefix, uri]
+          ns = ::Moxml::Adapter::CustomizedOx::Namespace.new(prefix, uri, element)
+          set_attribute(element, ns.expanded_prefix, uri)
+          ns
         end
 
         def set_namespace(element, ns)
-          prefix, uri = ns
-          element.attributes ||= {}
-          attr_name = prefix ? "xmlns:#{prefix}" : "xmlns"
-          element.attributes[attr_name] = uri
+          return unless element.respond_to?(:name)
+
+          prefix = ns.prefix
+          # attributes don't have attributes but can have a namespace prefix
+          set_attribute(element, ns.expanded_prefix, ns.uri) if element.respond_to?(:attributes)
+          element.name = [prefix, element.name.delete_prefix("xmlns:")].compact.join(":")
+          namespace(element)
         end
 
         def namespace(element)
-          return nil unless element.attributes
+          prefix =
+            if element.respond_to?(:prefix)
+              # attribute
+              element.prefix
+            elsif element.name.include?(":")
+              element.name.split(":").first
+            end
+          attr_name = ["xmlns", prefix].compact.join(":")
 
-          xmlns_attr = element.attributes.find { |k, _| k.start_with?("xmlns:") || k == "xmlns" }
-          return nil unless xmlns_attr
+          ([element] + ancestors(element)).each do |node|
+            next unless node.respond_to?(:attributes) && node.attributes
 
-          prefix = xmlns_attr[0] == "xmlns" ? nil : xmlns_attr[0].sub("xmlns:", "")
-          [prefix, xmlns_attr[1]]
+            if node[attr_name]
+              return ::Moxml::Adapter::CustomizedOx::Namespace.new(
+                prefix, node[attr_name], element
+              )
+            end
+          end
+
+          nil
+        end
+
+        def ancestors(node)
+          return [] unless (parent = parent(node))
+
+          [parent] + ancestors(parent)
         end
 
         def processing_instruction_target(node)
-          node.name
+          node.target
         end
 
         def node_type(node)
           case node
           when ::Ox::Document then :document
-          when String then :text
+          when ::Moxml::Adapter::CustomizedOx::Text, String then :text
           when ::Ox::CData then :cdata
           when ::Ox::Comment then :comment
           when ::Ox::Instruct then :processing_instruction
           when ::Ox::Element then :element
+          when ::Ox::DocType then :doctype
+          when ::Moxml::Adapter::CustomizedOx::Namespace then :banespace
+          when ::Moxml::Adapter::CustomizedOx::Attribute then :attribute
           else :unknown
           end
         end
@@ -120,8 +157,40 @@ module Moxml
         end
 
         def set_node_name(node, name)
-          node.value = name if node.respond_to?(:value=)
-          node.name = name if node.respond_to?(:name=)
+          if node.respond_to?(:name=)
+            node.name = name
+          elsif node.respond_to?(:value=)
+            node.value = name
+          end
+        end
+
+        def duplicate_node(node)
+          Marshal.load(Marshal.dump(node))
+        end
+
+        def patch_node(node, parent = nil)
+          new_node =
+            case node
+            # it can be either attribute or namespace
+            when Array then ::Moxml::Adapter::CustomizedOx::Attribute.new(node.first, node.last)
+            when Hash then ::Moxml::Adapter::CustomizedOx::Attribute.new(node.keys.first, node.values.first)
+            when String then ::Moxml::Adapter::CustomizedOx::Text.new(node)
+            else node
+            end
+
+          new_node.parent = parent if new_node.respond_to?(:parent)
+
+          new_node
+        end
+
+        def unpatch_node(node)
+          case node
+          # it can be either attribute or namespace
+          when ::Moxml::Adapter::CustomizedOx::Attribute then [node.name, node.value]
+          # when ::Moxml::Adapter::CustomizedOx::Attribute then { node.name => node.value }
+          when ::Moxml::Adapter::CustomizedOx::Text then node.value
+          else node
+          end
         end
 
         def children(node)
@@ -135,19 +204,19 @@ module Moxml
         end
 
         def next_sibling(node)
-          return unless (parent = parent(node))
+          return unless (parent = node.parent)
 
           siblings = parent.nodes
-          idx = siblings.index(node)
-          idx ? siblings[idx + 1] : nil
+          idx = siblings.index(unpatch_node(node))
+          idx ? patch_node(siblings[idx + 1], parent) : nil
         end
 
         def previous_sibling(node)
           return unless (parent = parent(node))
 
           siblings = parent.nodes
-          idx = siblings.index(node)
-          idx&.positive? ? siblings[idx - 1] : nil
+          idx = siblings.index(unpatch_node(node))
+          idx&.positive? ? patch_node(siblings[idx - 1], parent) : nil
         end
 
         def document(node)
@@ -161,74 +230,153 @@ module Moxml
         end
 
         def attributes(element)
-          return {} unless element.respond_to?(:attributes) && element.attributes
+          return [] unless element.respond_to?(:attributes) && element.attributes
 
-          element.attributes.reject { |k, _| k.start_with?("xmlns") }
+          element.attributes.map do |name, value|
+            next if name.start_with?("xmlns")
+
+            ::Moxml::Adapter::CustomizedOx::Attribute.new(
+              name, value, element
+            )
+          end.compact
+        end
+
+        def attribute_element(attribute)
+          attribute.parent
         end
 
         def set_attribute(element, name, value)
           element.attributes ||= {}
-          element.attributes[name.to_s] = value.to_s
+          if value.nil?
+            # Ox converts all values to strings
+            remove_attribute(element, name)
+          else
+            element.attributes[name.to_s] = value
+          end
+
+          ::Moxml::Adapter::CustomizedOx::Attribute.new(
+            name.to_s, value&.to_s, element
+          )
+        end
+
+        def set_attribute_name(attribute, name)
+          old_name = attribute.name
+          attribute.name = name.to_s
+          # Ox doesn't change the keys of the attributes hash
+          element = attribute.parent
+          element.attributes.delete(old_name)
+          element.attributes[name] = attribute.value
+        end
+
+        def set_attribute_value(attribute, new_value)
+          if new_value.nil?
+            # Ox converts all values to strings
+            remove_attribute(attribute.parent, attribute.name)
+          else
+            attribute.value = new_value
+            attribute.parent.attributes[attribute.name] = new_value
+          end
         end
 
         def get_attribute(element, name)
-          return nil unless element.respond_to?(:attributes) && element.attributes
+          return unless element.respond_to?(:attributes) && element.attributes
+          return unless element.attributes.key?(name.to_s) || element.attributes.key?(name.to_s.to_sym)
+
+          ::Moxml::Adapter::CustomizedOx::Attribute.new(
+            name.to_s, element.attributes[name], element
+          )
+        end
 
-          element.attributes[name.to_s]
+        def get_attribute_value(element, name)
+          element[name]
         end
 
         def remove_attribute(element, name)
           return unless element.respond_to?(:attributes) && element.attributes
 
           element.attributes.delete(name.to_s)
+          element.attributes.delete(name.to_s.to_sym)
         end
 
         def add_child(element, child)
+          child.parent = element if child.respond_to?(:parent)
           element.nodes ||= []
-          puts "Add child #{child} for #{element.name}: #{element.nodes.count}"
           element.nodes << child
         end
 
         def add_previous_sibling(node, sibling)
-          return unless parent(node)
+          return unless (parent = parent(node))
 
-          idx = node.parent.nodes.index(node)
-          node.parent.nodes.insert(idx, sibling) if idx
+          if sibling.respond_to?(:parent)
+            sibling.parent&.nodes&.delete(sibling)
+            sibling.parent = parent
+          end
+          idx = parent.nodes.index(node)
+          parent.nodes.insert(idx, sibling) if idx
         end
 
         def add_next_sibling(node, sibling)
-          return unless parent(node)
+          return unless (parent = parent(node))
 
-          idx = node.parent.nodes.index(node)
-          node.parent.nodes.insert(idx + 1, sibling) if idx
+          if sibling.respond_to?(:parent)
+            sibling.parent&.nodes&.delete(sibling)
+            sibling.parent = parent
+          end
+          idx = parent.nodes.index(node)
+          parent.nodes.insert(idx + 1, sibling) if idx
         end
 
         def remove(node)
+          return node.clear if node.is_a?(String)
+
           return unless parent(node)
 
-          node.parent.nodes.delete(node)
+          parent(node).nodes.delete(node)
         end
 
         def replace(node, new_node)
-          return unless parent(node)
+          return node.replace(new_node) if node.is_a?(String) && new_node.is_a?(String)
+          # There are other cases:
+          # when node is a String and new_node isn't
+          # when node isn't a String, and new_node is a String
+
+          return unless (parent = parent(node))
 
-          idx = node.parent.nodes.index(node)
-          node.parent.nodes[idx] = new_node if idx
+          new_node.parent = parent if new_node.respond_to?(:parent)
+          idx = parent.nodes.index(node)
+          parent.nodes[idx] = new_node if idx
         end
 
         def replace_children(node, new_children)
           node.remove_children_by_path("*")
-          new_children.each { |child| node << child }
+          new_children.each do |child|
+            child.parent = node if child.respond_to?(:parent)
+            node << child
+          end
           node
         end
 
         def text_content(node)
-          node.is_a?(String) ? node : node.value.to_s
+          case node
+          when String then node.to_s
+          when ::Moxml::Adapter::CustomizedOx::Text then node.value
+          else
+            node.nodes.map do |n|
+              text_content(n)
+            end.join
+          end
+        end
+
+        def inner_text(node)
+          return "" unless node.respond_to?(:nodes)
+
+          node.nodes.select { _1.is_a?(String) }.join
         end
 
         def set_text_content(node, content)
-          if node.is_a?(String)
-            node.replace(content.to_s)
+          case node
+          when String then node.replace(content.to_s)
+          when ::Ox::Element then node.replace_text(content.to_s)
           else
             node.value = content.to_s
           end
@@ -251,48 +399,60 @@ module Moxml
         end
 
         def processing_instruction_content(node)
-          node.value.to_s
+          node.content.to_s
         end
 
         def set_processing_instruction_content(node, content)
-          node.value = content.to_s
+          node.content = content.to_s
+        end
+
+        def namespace_prefix(namespace)
+          namespace.prefix
+        end
+
+        def namespace_uri(namespace)
+          namespace.uri
         end
 
         def namespace_definitions(node)
-          return [] unless node.respond_to?(:attributes) && node.attributes
+          ([node] + ancestors(node)).reverse.each_with_object({}) do |n, namespaces|
+            next unless n.respond_to?(:attributes) && n.attributes
 
-          node.attributes.each_with_object([]) do |(name, value), namespaces|
-            next unless name.start_with?("xmlns")
+            n.attributes.each do |name, value|
+              next unless name.to_s.start_with?("xmlns")
 
-            prefix = name == "xmlns" ? nil : name.sub("xmlns:", "")
-            namespaces << [prefix, value]
-          end
+              namespaces[name] = ::Moxml::Adapter::CustomizedOx::Namespace.new(
+                name, value, n
+              )
+            end
+          end.values
         end
 
-        def xpath(node, expression, namespaces = {})
-          # Ox doesn't support XPath, implement basic path matching
-          results = []
-          traverse(node) do |n|
-            results << n if matches_xpath?(n, expression, namespaces)
-          end
-          results
+        def xpath(node, expression, _namespaces = {})
+          # locate has a different syntax
+          node.locate(expression)
         end
 
         def at_xpath(node, expression, namespaces = {})
-          traverse(node) do |n|
-            return n if matches_xpath?(n, expression, namespaces)
-          end
-          nil
+          xpath(node, expression, namespaces)&.first
         end
 
         def serialize(node, options = {})
+          output = ""
+          if node.is_a?(::Ox::Document)
+            # add declaration
+            decl = create_native_declaration(node[:version], node[:encoding], node[:standalone])
+            output = ::Ox.dump(::Ox::Document.new << decl).strip
+          end
+
           ox_options = {
-            indent: options[:indent] || -1,
-            with_xml: true,
+            indent: -1, # options[:indent] || -1, # indent is a beast
+            # with_xml: true,
             with_instructions: true,
-            encoding: options[:encoding]
+            encoding: options[:encoding],
+            no_empty: options[:expand_empty]
           }
-          ::Ox.dump(node, ox_options)
+          output + ::Ox.dump(node, ox_options)
         end
 
         private
@@ -305,20 +465,6 @@ module Moxml
 
           node.nodes&.each { |child| traverse(child, &block) }
         end
-
-        def matches_xpath?(node, expression, _namespaces = {})
-          case expression
-          when %r{//(\w+)}
-            node.is_a?(::Ox::Element) && node.value == ::Regexp.last_match(1)
-          when %r{//(\w+)\[@(\w+)='([^']+)'\]}
-            node.is_a?(::Ox::Element) &&
-              node.value == ::Regexp.last_match(1) &&
-              node.attributes &&
-              node.attributes[::Regexp.last_match(2)] == ::Regexp.last_match(3)
-          else
-            false
-          end
-        end
       end
     end
   end