moxml 0.1.4 → 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

data/lib/moxml/adapter/rexml.rb

@@ -21,7 +21,7 @@ module Moxml
           DocumentBuilder.new(Context.new(:rexml)).build(native_doc)
         end
 
-        def create_document
+        def create_document(_native_doc = nil)
           ::REXML::Document.new
         end
 
@@ -75,6 +75,8 @@ module Moxml
           when ::REXML::CData then :cdata
           when ::REXML::Text then :text
           when ::REXML::Comment then :comment
+          when ::REXML::Attribute then :attribute # but in fact it may be a namespace as well
+          when ::REXML::Namespace then :namespace # we don't use this one
           when ::REXML::Instruction then :processing_instruction
           when ::REXML::DocType then :doctype
           when ::REXML::XMLDecl then :declaration
@@ -325,7 +327,7 @@ module Moxml
         def inner_text(node)
           # Get direct text children only, filter duplicates
           text_children = node.children
-                              .select { |c| c.is_a?(::REXML::Text) }
+                              .select { _1.is_a?(::REXML::Text) }
                               .uniq(&:object_id)
           text_children.map(&:value).join
         end
@@ -380,6 +382,8 @@ module Moxml
           end
         end
 
+        # not used at the moment
+        # but may be useful when the xpath is upgraded to work with namespaces
         def prepare_xpath_namespaces(node)
           ns = {}
 
@@ -430,10 +434,10 @@ module Moxml
 
             # Write processing instructions
             node.children.each do |child|
-              if child.is_a?(::REXML::Instruction)
-                child.write(output)
-                # output << "\n"
-              end
+              next unless [::REXML::Instruction, ::REXML::CData, ::REXML::Comment, ::REXML::Text].include?(child.class)
+
+              write_with_formatter(child, output, options[:indent] || 2)
+              # output << "\n"
             end
 
             write_with_formatter(node.root, output, options[:indent] || 2) if node.root

data/lib/moxml/adapter.rb

@@ -4,7 +4,7 @@ require_relative "adapter/base"
 
 module Moxml
   module Adapter
-    AVALIABLE_ADAPTERS = %i[nokogiri oga rexml].freeze # ox to be added later
+    AVALIABLE_ADAPTERS = %i[nokogiri oga rexml ox].freeze
 
     class << self
       def load(name)

data/lib/moxml/cdata.rb

@@ -9,9 +9,5 @@ module Moxml
     def content=(text)
       adapter.set_cdata_content(@native, normalize_xml_value(text))
     end
-
-    def cdata?
-      true
-    end
   end
 end

data/lib/moxml/comment.rb

@@ -11,9 +11,5 @@ module Moxml
       adapter.validate_comment_content(text)
       adapter.set_comment_content(@native, text)
     end
-
-    def comment?
-      true
-    end
   end
 end

data/lib/moxml/context.rb

@@ -8,8 +8,8 @@ module Moxml
       @config = Config.new(adapter)
     end
 
-    def create_document
-      Document.new(config.adapter.create_document, self)
+    def create_document(native_doc = nil)
+      Document.new(config.adapter.create_document(native_doc), self)
     end
 
     def parse(xml, options = {})

data/lib/moxml/doctype.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  class Doctype < Node
-    def doctype?
-      true
-    end
-  end
+  class Doctype < Node; end
 end

data/lib/moxml/document.rb

@@ -63,7 +63,7 @@ module Moxml
         if children.empty?
           adapter.add_child(@native, node.native)
         else
-          adapter.add_previous_sibling(children.first.native, node.native)
+          adapter.add_previous_sibling(adapter.children(@native).first, node.native)
         end
       elsif root && !node.is_a?(ProcessingInstruction) && !node.is_a?(Comment)
         raise Error, "Document already has a root element"

data/lib/moxml/document_builder.rb

@@ -10,7 +10,7 @@ module Moxml
     end
 
     def build(native_doc)
-      @current_doc = context.create_document
+      @current_doc = context.create_document(native_doc)
       visit_node(native_doc)
       @current_doc
     end

data/lib/moxml/element.rb

@@ -52,7 +52,8 @@ module Moxml
       ns && Namespace.new(ns, context)
     end
 
-    # it does NOT change the list of namespace definitions
+    # add the prefix to the element name
+    # and add the namespace to the list of namespace definitions
     def namespace=(ns_or_hash)
       if ns_or_hash.is_a?(Hash)
         adapter.set_namespace(

data/lib/moxml/namespace.rb

@@ -22,6 +22,10 @@ module Moxml
       end
     end
 
+    def default?
+      prefix.nil? || prefix.to_s == "xmlns"
+    end
+
     def namespace?
       true
     end

data/lib/moxml/node.rb

@@ -7,11 +7,17 @@ module Moxml
   class Node
     include XmlUtils
 
+    TYPES = %i[
+      element text cdata comment processing_instruction document
+      declaration doctype namespace attribute unknown
+    ].freeze
+
     attr_reader :native, :context
 
     def initialize(native, context)
-      @native = native
       @context = context
+      # @native = adapter.patch_node(native)
+      @native = native
     end
 
     def document
@@ -23,7 +29,10 @@ module Moxml
     end
 
     def children
-      NodeSet.new(adapter.children(@native), context)
+      NodeSet.new(
+        adapter.children(@native).map { adapter.patch_node(_1, @native) },
+        context
+      )
     end
 
     def next_sibling
@@ -79,6 +88,12 @@ module Moxml
       self.class == other.class && @native == other.native
     end
 
+    TYPES.each do |node_type|
+      define_method "#{node_type}?" do
+        adapter.node_type(native) == node_type
+      end
+    end
+
     def self.wrap(node, context)
       return nil if node.nil?