moxml 0.1.3 → 0.1.6

data/lib/moxml/adapter/customized_rexml/formatter.rb

@@ -0,0 +1,195 @@
+require "rexml/formatters/pretty"
+
+module Moxml
+  module Adapter
+    module CustomizedRexml
+      # Custom REXML formatter that fixes indentation and wrapping issues
+      class Formatter < ::REXML::Formatters::Pretty
+        def initialize(indentation: 2, self_close_empty: false)
+          @indentation = " " * indentation
+          @level = 0
+          @compact = true
+          @width = -1 # Disable line wrapping
+          @self_close_empty = self_close_empty
+        end
+
+        def write(node, output)
+          case node
+          when ::REXML::XMLDecl
+            write_declaration(node, output)
+          else
+            super
+          end
+        end
+
+        def write_element(node, output)
+          # output << ' ' * @level
+          output << "<#{node.expanded_name}"
+          write_attributes(node, output)
+
+          if node.children.empty? && @self_close_empty
+            output << "/>"
+            return
+          end
+
+          output << ">"
+
+          # Check for mixed content
+          has_text = node.children.any? { |c| c.is_a?(::REXML::Text) && !c.to_s.strip.empty? }
+          has_elements = node.children.any? { |c| c.is_a?(::REXML::Element) }
+          mixed = has_text && has_elements
+
+          # Handle children based on content type
+          unless node.children.empty?
+            @level += @indentation.length unless mixed
+
+            node.children.each_with_index do |child, _index|
+              # Skip insignificant whitespace
+              next if child.is_a?(::REXML::Text) &&
+                      child.to_s.strip.empty? &&
+                      !(child.next_sibling.nil? && child.previous_sibling.nil?)
+
+              # Indent non-text nodes in non-mixed content
+              # if !mixed && !child.is_a?(::REXML::Text)
+              #   output << ' ' * @level
+              # end
+
+              write(child, output)
+
+              # Add newlines between elements in non-mixed content
+              # if !mixed && !child.is_a?(::REXML::Text) && index < node.children.size - 1
+              #   output << "\n"
+              # end
+            end
+
+            # Reset indentation for closing tag in non-mixed content
+            unless mixed
+              @level -= @indentation.length
+              # output << ' ' * @level
+            end
+          end
+
+          output << "</#{node.expanded_name}>"
+          # output << "\n" unless mixed
+        end
+
+        def write_text(node, output)
+          text = node.value
+          return if text.empty?
+
+          output << escape_text(text)
+        end
+
+        def escape_text(text)
+          text.to_s.gsub(/[<>&]/) do |match|
+            case match
+            when "<" then "&lt;"
+            when ">" then "&gt;"
+            when "&" then "&amp;"
+            end
+          end
+        end
+
+        private
+
+        def find_significant_sibling(node, direction)
+          method = direction == :next ? :next_sibling : :previous_sibling
+          sibling = node.send(method)
+          sibling = sibling.send(method) while sibling && sibling.is_a?(::REXML::Text) && sibling.to_s.strip.empty?
+          sibling
+        end
+
+        def write_cdata(node, output)
+          # output << ' ' * @level
+          output << ::REXML::CData::START
+          output << node.to_s.gsub(::REXML::CData::STOP, "]]]]><![CDATA[>")
+          output << ::REXML::CData::STOP
+          # output << "\n"
+        end
+
+        def write_comment(node, output)
+          # output << ' ' * @level
+          output << "<!--"
+          output << node.to_s
+          output << "-->"
+          # output << "\n"
+        end
+
+        def write_instruction(node, output)
+          # output << ' ' * @level
+          output << "<?"
+          output << node.target
+          output << " "
+          output << node.content if node.content
+          output << "?>"
+          # output << "\n"
+        end
+
+        def write_document(node, output)
+          node.children.each do |child|
+            write(child, output)
+            # output << "\n" unless child == node.children.last
+          end
+        end
+
+        def write_doctype(node, output)
+          output << "<!DOCTYPE "
+          output << node.name
+          output << " "
+          output << node.external_id if node.external_id
+          output << ">"
+          # output << "\n"
+        end
+
+        def write_declaration(node, output)
+          output << "<?xml"
+          output << %( version="#{node.version}") if node.version
+          output << %( encoding="#{node.encoding.to_s.upcase}") if node.writeencoding
+          output << %( standalone="#{node.standalone}") if node.standalone
+          output << "?>"
+          # output << "\n"
+        end
+
+        def write_attributes(node, output)
+          # First write namespace declarations
+          node.attributes.each do |name, attr|
+            next unless name.to_s.start_with?("xmlns:") || name.to_s == "xmlns"
+
+            name = "xmlns" if name.to_s == "xmlns:" # convert the default namespace
+            value = attr.respond_to?(:value) ? attr.value : attr
+            output << " #{name}=\"#{value}\""
+          end
+
+          # Then write regular attributes
+          node.attributes.each do |name, attr|
+            next if name.to_s.start_with?("xmlns:") || name.to_s == "xmlns"
+
+            output << " "
+            output << if attr.respond_to?(:prefix) && attr.prefix
+                        "#{attr.prefix}:#{attr.name}"
+                      else
+                        name.to_s
+                      end
+
+            output << "=\""
+            value = attr.respond_to?(:value) ? attr.value : attr
+            output << escape_attribute_value(value.to_s)
+            output << "\""
+          end
+        end
+
+        def escape_attribute_value(value)
+          value.to_s.gsub(/[<>&"]/) do |match|
+            case match
+            when "<" then "&lt;"
+            when ">" then "&gt;"
+            when "&" then "&amp;"
+            when '"' then "&quot;"
+              # when "'" then '&apos;'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moxml/adapter/nokogiri.rb

@@ -31,7 +31,7 @@ module Moxml
           DocumentBuilder.new(Context.new(:nokogiri)).build(native_doc)
         end
 
-        def create_document
+        def create_document(_native_doc = nil)
           ::Nokogiri::XML::Document.new
         end
 
@@ -120,6 +120,8 @@ module Moxml
           when ::Nokogiri::XML::CDATA then :cdata
           when ::Nokogiri::XML::Text then :text
           when ::Nokogiri::XML::Comment then :comment
+          when ::Nokogiri::XML::Attr then :attribute
+          when ::Nokogiri::XML::Namespace then :namespace
           when ::Nokogiri::XML::ProcessingInstruction then :processing_instruction
           when ::Nokogiri::XML::Document, ::Nokogiri::XML::DocumentFragment then :document
           when ::Nokogiri::XML::DTD then :doctype
@@ -221,7 +223,7 @@ module Moxml
         end
 
         def text_content(node)
-          node.content
+          node.text
         end
 
         def inner_text(node)

data/lib/moxml/adapter/oga.rb

@@ -24,7 +24,7 @@ module Moxml
           DocumentBuilder.new(Context.new(:oga)).build(native_doc)
         end
 
-        def create_document
+        def create_document(_native_doc = nil)
           ::Oga::XML::Document.new
         end
 
@@ -111,6 +111,8 @@ module Moxml
           when ::Oga::XML::Text then :text
           when ::Oga::XML::Cdata then :cdata
           when ::Oga::XML::Comment then :comment
+          when ::Oga::XML::Attribute then :attribute
+          when ::Oga::XML::Namespace then :namespace
           when ::Oga::XML::ProcessingInstruction then :processing_instruction
           when ::Oga::XML::Document then :document
           when ::Oga::XML::Doctype then :doctype
@@ -213,11 +215,25 @@ module Moxml
         end
 
         def add_previous_sibling(node, sibling)
-          node.before(sibling)
+          if node.parent == sibling.parent
+            # Oga doesn't manipulate children of the same parent
+            dup_sibling = node.node_set.delete(sibling)
+            index = node.node_set.index(node)
+            node.node_set.insert(index, dup_sibling)
+          else
+            node.before(sibling)
+          end
         end
 
         def add_next_sibling(node, sibling)
-          node.after(sibling)
+          if node.parent == sibling.parent
+            # Oga doesn't manipulate children of the same parent
+            dup_sibling = node.node_set.delete(sibling)
+            index = node.node_set.index(node) + 1
+            node.node_set.insert(index, dup_sibling)
+          else
+            node.after(sibling)
+          end
         end
 
         def remove(node)
@@ -229,7 +245,7 @@ module Moxml
         end
 
         def replace_children(node, new_children)
-          node.inner_text = ""
+          node.children = []
           new_children.each { |child| add_child(node, child) }
         end
 
@@ -247,7 +263,7 @@ module Moxml
         end
 
         def set_text_content(node, content)
-          if node.respond_to?(:inner_text)
+          if node.respond_to?(:inner_text=)
             node.inner_text = content
           else
             # Oga::XML::Text node for example
@@ -296,14 +312,14 @@ module Moxml
           node.namespaces.values
         end
 
-        def xpath(node, expression, _namespaces = {})
-          node.xpath(expression).to_a
+        def xpath(node, expression, namespaces = nil)
+          node.xpath(expression, {}, namespaces: namespaces&.transform_keys(&:to_s)).to_a
         rescue ::LL::ParserError => e
           raise Moxml::XPathError, e.message
         end
 
-        def at_xpath(node, expression, _namespaces = {})
-          node.at_xpath(expression)
+        def at_xpath(node, expression, namespaces = nil)
+          node.at_xpath(expression, namespaces: namespaces)
         rescue ::Oga::XPath::Error => e
           raise Moxml::XPathError, e.message
         end