moxml 0.1.14 → 0.1.16

data/lib/moxml/adapter/ox.rb

@@ -3,9 +3,7 @@
 require_relative "base"
 require "ox"
 require "stringio"
-require_relative "customized_ox/text"
-require_relative "customized_ox/attribute"
-require_relative "customized_ox/namespace"
+require_relative "customized_ox"
 
 # insert :parent methods to all Ox classes inherit the Node class
 Ox::Node.attr_accessor :parent
@@ -13,20 +11,27 @@ module Moxml
   module Adapter
     class Ox < Base
       class << self
+        def attachments
+          @attachments ||= Moxml::NativeAttachment.new
+        end
+
         def set_root(doc, element)
           replace_children(doc, [element])
         end
 
-        def parse(xml, _options = {}, _context = nil)
+        def parse(xml, options = {}, _context = nil)
           native_doc = begin
             result = ::Ox.parse(xml)
 
             # result can be either Document or Element
             if result.is_a?(::Ox::Document)
+              assign_parents(result)
+              validate_single_root(result) if options[:strict]
               result
             else
               doc = ::Ox::Document.new
               doc << result
+              assign_parents(doc)
               doc
             end
           rescue ::Ox::ParseError => e
@@ -37,7 +42,7 @@ module Moxml
           end
 
           ctx = _context || Context.new(:ox)
-          DocumentBuilder.new(ctx).build(native_doc)
+          Document.new(native_doc, ctx)
         end
 
         # SAX parsing implementation for Ox
@@ -50,7 +55,7 @@ module Moxml
           bridge = OxSAXBridge.new(handler)
 
           # Parse using Ox's SAX parser
-          xml_string = xml.respond_to?(:read) ? xml.read : xml.to_s
+          xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s
 
           begin
             ::Ox.sax_parse(bridge, StringIO.new(xml_string))
@@ -69,7 +74,6 @@ module Moxml
 
         def create_native_element(name, _owner_doc = nil)
           element = ::Ox::Element.new(name)
-          element.instance_variable_set(:@attributes, {})
           element
         end
 
@@ -77,6 +81,14 @@ module Moxml
           content
         end
 
+        def create_native_entity_reference(name)
+          ::Moxml::Adapter::CustomizedOx::EntityReference.new(name)
+        end
+
+        def entity_reference_name(node)
+          node.name if node.is_a?(::Moxml::Adapter::CustomizedOx::EntityReference)
+        end
+
         def create_native_cdata(content, _owner_doc = nil)
           ::Ox::CData.new(content)
         end
@@ -121,11 +133,11 @@ module Moxml
         end
 
         def set_namespace(element, ns)
-          return unless element.respond_to?(:name)
+          return unless element.is_a?(::Ox::Element) || element.is_a?(::Ox::Node)
 
           prefix = ns.prefix
           # attributes don't have attributes but can have a namespace prefix
-          if element.respond_to?(:attributes)
+          if element.is_a?(::Ox::Element)
             set_attribute(element, ns.expanded_prefix,
                           ns.uri)
           end
@@ -136,8 +148,7 @@ module Moxml
 
         def namespace(element)
           prefix =
-            if element.respond_to?(:prefix)
-              # attribute
+            if element.is_a?(::Moxml::Adapter::CustomizedOx::Attribute)
               element.prefix
             elsif element.name.include?(":")
               element.name.split(":").first
@@ -145,7 +156,7 @@ module Moxml
           attr_name = ["xmlns", prefix].compact.join(":")
 
           ([element] + ancestors(element)).each do |node|
-            next unless node.respond_to?(:attributes) && node.attributes
+            next unless node.is_a?(::Ox::Element) && node.attributes
 
             if node[attr_name]
               return ::Moxml::Adapter::CustomizedOx::Namespace.new(
@@ -176,6 +187,7 @@ module Moxml
           when ::Ox::Instruct then :processing_instruction
           when ::Ox::Element then :element
           when ::Ox::DocType then :doctype
+          when ::Moxml::Adapter::CustomizedOx::EntityReference then :entity_reference
           when ::Moxml::Adapter::CustomizedOx::Namespace then :banespace
           when ::Moxml::Adapter::CustomizedOx::Attribute then :attribute
           else :unknown
@@ -194,10 +206,9 @@ module Moxml
         end
 
         def set_node_name(node, name)
-          if node.respond_to?(:name=)
-            node.name = name
-          elsif node.respond_to?(:value=)
-            node.value = name
+          case node
+          when ::Ox::Element then node.name = name
+          when ::Ox::Instruct then node.value = name
           end
         end
 
@@ -219,7 +230,7 @@ module Moxml
             else node
             end
 
-          new_node.parent = parent if new_node.respond_to?(:parent)
+          new_node.parent = parent if new_node.is_a?(::Ox::Node)
 
           new_node
         end
@@ -231,18 +242,25 @@ module Moxml
                                                                node.value]
           # when ::Moxml::Adapter::CustomizedOx::Attribute then { node.name => node.value }
           when ::Moxml::Adapter::CustomizedOx::Text then node.value
+          when ::Moxml::Adapter::CustomizedOx::EntityReference then node
           else node
           end
         end
 
         def children(node)
-          return [] unless node.respond_to?(:nodes)
+          return [] unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
-          node.nodes || []
+          result = node.nodes || []
+          # Ox doesn't set parent references during parsing.
+          # Set them here so parent/sibling navigation works.
+          result.each do |child|
+            child.parent = node if child.respond_to?(:parent=)
+          end
+          result
         end
 
         def parent(node)
-          node.parent if node.respond_to?(:parent)
+          node.parent if node.is_a?(::Ox::Node)
         end
 
         def next_sibling(node)
@@ -272,9 +290,7 @@ module Moxml
         end
 
         def attributes(element)
-          unless element.respond_to?(:attributes) && element.attributes
-            return []
-          end
+          return [] unless element.is_a?(::Ox::Element) && element.attributes
 
           element.attributes.filter_map do |name, value|
             next if name.to_s.start_with?("xmlns")
@@ -324,7 +340,7 @@ module Moxml
         end
 
         def get_attribute(element, name)
-          return unless element.respond_to?(:attributes) && element.attributes
+          return unless element.is_a?(::Ox::HasAttrs) && element.attributes
           unless element.attributes.key?(name.to_s) || element.attributes.key?(name.to_s.to_sym)
             return
           end
@@ -342,7 +358,7 @@ module Moxml
         end
 
         def remove_attribute(element, name)
-          return unless element.respond_to?(:attributes) && element.attributes
+          return unless element.is_a?(::Ox::HasAttrs) && element.attributes
 
           element.attributes.delete(name.to_s)
           element.attributes.delete(name.to_s.to_sym)
@@ -367,15 +383,24 @@ module Moxml
             end
           end
 
-          child.parent = element if child.respond_to?(:parent)
+          child.parent = element if child.is_a?(::Ox::Node)
           element.nodes ||= []
           element.nodes << child
+
+          # Mark document if EntityReference is added (avoids tree scan in serialize)
+          if child.is_a?(::Moxml::Adapter::CustomizedOx::EntityReference)
+            root = element
+            while root.is_a?(::Ox::Node) && root.parent
+              root = root.parent
+            end
+            attachments.set(root, :has_entity_refs, true) if root
+          end
         end
 
         def add_previous_sibling(node, sibling)
           return unless (parent = parent(node))
 
-          if sibling.respond_to?(:parent)
+          if sibling.is_a?(::Ox::Node)
             sibling.parent&.nodes&.delete(sibling)
             sibling.parent = parent
           end
@@ -386,7 +411,7 @@ module Moxml
         def add_next_sibling(node, sibling)
           return unless (parent = parent(node))
 
-          if sibling.respond_to?(:parent)
+          if sibling.is_a?(::Ox::Node)
             sibling.parent&.nodes&.delete(sibling)
             sibling.parent = parent
           end
@@ -421,7 +446,7 @@ module Moxml
 
           return unless (parent = parent(node))
 
-          new_node.parent = parent if new_node.respond_to?(:parent)
+          new_node.parent = parent if new_node.is_a?(::Ox::Node)
           idx = parent.nodes.index(node)
           parent.nodes[idx] = new_node if idx
         end
@@ -429,20 +454,40 @@ module Moxml
         def replace_children(node, new_children)
           node.remove_children_by_path("*")
           new_children.each do |child|
-            child.parent = node if child.respond_to?(:parent)
+            child.parent = node if child.is_a?(::Ox::Node)
             node << child
           end
           node
         end
 
+        def assign_parents(node, parent = nil)
+          node.parent = parent if node.respond_to?(:parent=) && parent
+          return unless node.respond_to?(:nodes)
+
+          node.nodes&.each do |child|
+            assign_parents(child, node)
+          end
+        end
+
+        def validate_single_root(document)
+          elements = document.nodes&.grep(::Ox::Element) || []
+          return unless elements.size > 1
+
+          raise Moxml::ParseError.new(
+            "Multiple root elements found",
+            source: nil,
+          )
+        end
+
         def text_content(node)
           return "" if node.nil?
 
           case node
           when String then node.to_s
           when ::Moxml::Adapter::CustomizedOx::Text then node.value
+          when ::Moxml::Adapter::CustomizedOx::EntityReference then ""
           else
-            return "" unless node.respond_to?(:nodes)
+            return "" unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
             node.nodes.map do |n|
               text_content(n)
@@ -451,7 +496,7 @@ module Moxml
         end
 
         def inner_text(node)
-          return "" unless node.respond_to?(:nodes)
+          return "" unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
           node.nodes.grep(String).join
         end
@@ -499,7 +544,7 @@ module Moxml
 
         def namespace_definitions(node)
           ([node] + ancestors(node)).reverse.each_with_object({}) do |n, namespaces|
-            next unless n.respond_to?(:attributes) && n.attributes
+            next unless n.is_a?(::Ox::Element) && n.attributes
 
             n.attributes.each do |name, value|
               next unless name.to_s.start_with?("xmlns")
@@ -575,18 +620,35 @@ module Moxml
         end
 
         def serialize(node, options = {})
+          # Fast path: skip EntityReference scan for documents (most common case)
+          if node.is_a?(::Ox::Document) &&
+              !attachments.get(node, :has_entity_refs)
+            return serialize_standard(node, options)
+          end
+
+          if tree_has_entity_references?(node)
+            serialize_custom(node, options)
+          else
+            serialize_standard(node, options)
+          end
+        end
+
+        def has_declaration?(native_doc, _wrapper)
+          # Ox stores declaration in document attributes
+          native_doc[:version] || native_doc[:encoding] || native_doc[:standalone]
+        end
+
+        private
+
+        def serialize_standard(node, options = {})
           output = ""
           if node.is_a?(::Ox::Document)
-            # Check if we should include declaration
-            # Priority: explicit option > document attributes
             should_include_decl = if options.key?(:no_declaration)
                                     !options[:no_declaration]
                                   else
-                                    # Check if document has declaration attributes
                                     node[:version] || node[:encoding] || node[:standalone]
                                   end
 
-            # Only add declaration if should_include_decl is true
             if should_include_decl
               version = node[:version] || "1.0"
               encoding = options[:encoding] || node[:encoding]
@@ -598,8 +660,7 @@ module Moxml
           end
 
           ox_options = {
-            indent: -1, # options[:indent] || -1, # indent is a beast
-            # with_xml: true,
+            indent: -1,
             with_instructions: true,
             encoding: options[:encoding],
             no_empty: options[:expand_empty],
@@ -607,7 +668,102 @@ module Moxml
           output + ::Ox.dump(node, ox_options)
         end
 
-        private
+        def tree_has_entity_references?(node)
+          case node
+          when ::Moxml::Adapter::CustomizedOx::EntityReference
+            true
+          when ::Ox::Element
+            node.nodes&.any? do |child|
+              tree_has_entity_references?(child)
+            end || false
+          when ::Ox::Document
+            node.nodes&.any? do |child|
+              tree_has_entity_references?(child)
+            end || false
+          else
+            false
+          end
+        end
+
+        def serialize_custom(node, options = {})
+          output = +""
+          if node.is_a?(::Ox::Document)
+            should_include_decl = if options.key?(:no_declaration)
+                                    !options[:no_declaration]
+                                  else
+                                    node[:version] || node[:encoding] || node[:standalone]
+                                  end
+            if should_include_decl
+              version = node[:version] || "1.0"
+              encoding = options[:encoding] || node[:encoding]
+              standalone = node[:standalone]
+              output << "<?xml version=\"#{version}\""
+              output << " encoding=\"#{encoding}\"" if encoding
+              output << " standalone=\"#{standalone}\"" if standalone
+              output << "?>"
+            end
+            (node.nodes || []).each do |child|
+              output << serialize_node_custom(child)
+            end
+          else
+            output << serialize_node_custom(node)
+          end
+          output
+        end
+
+        def serialize_node_custom(node)
+          case node
+          when ::Ox::Element then serialize_element_custom(node)
+          when String then escape_xml_text(node)
+          when ::Moxml::Adapter::CustomizedOx::Text then escape_xml_text(node.value)
+          when ::Moxml::Adapter::CustomizedOx::EntityReference then "&#{node.name};"
+          when ::Ox::CData then "<![CDATA[#{node.value}]]>"
+          when ::Ox::Comment then "<!--#{node.value}-->"
+          when ::Ox::Instruct then "<?#{node.target} #{node.value || ''}?>"
+          when ::Ox::DocType then "<!DOCTYPE #{node.value}>"
+          else ""
+          end
+        end
+
+        def serialize_element_custom(elem)
+          output = "<#{elem.name}"
+          elem.attributes.each do |name, value|
+            output << " #{name}=\"#{escape_xml_attribute(value.to_s)}\""
+          end
+
+          if elem.nodes.nil? || elem.nodes.empty?
+            output << "/>"
+            return output
+          end
+
+          output << ">"
+          elem.nodes.each do |child|
+            output << serialize_node_custom(child)
+          end
+          output << "</#{elem.name}>"
+          output
+        end
+
+        def escape_xml_text(text)
+          text.to_s.gsub(/[<>&]/) do |match|
+            case match
+            when "<" then "&lt;"
+            when ">" then "&gt;"
+            when "&" then "&amp;"
+            end
+          end
+        end
+
+        def escape_xml_attribute(value)
+          value.to_s.gsub(/[<>&"]/) do |match|
+            case match
+            when "<" then "&lt;"
+            when ">" then "&gt;"
+            when "&" then "&amp;"
+            when '"' then "&quot;"
+            end
+          end
+        end
 
         # Translate a subset of XPath to Ox locate() syntax
         # Supports: //element, /path/to/element, .//element, element[@attr]
@@ -659,7 +815,7 @@ module Moxml
 
           result = nil
           traverse(root) do |node|
-            next unless node.respond_to?(:nodes)
+            next unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
             node.nodes&.each do |child|
               if child.equal?(target_node)
@@ -676,7 +832,7 @@ module Moxml
           return unless node
 
           yield node
-          return unless node.respond_to?(:nodes)
+          return unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
 
           node.nodes&.each { |child| traverse(child, &block) }
         end

data/lib/moxml/adapter/rexml.rb

@@ -4,12 +4,16 @@ require_relative "base"
 require "rexml/document"
 require "rexml/xpath"
 require "set"
-require_relative "customized_rexml/formatter"
+require_relative "customized_rexml"
 
 module Moxml
   module Adapter
     class Rexml < Base
       class << self
+        def attachments
+          @attachments ||= Moxml::NativeAttachment.new
+        end
+
         def parse(xml, options = {}, _context = nil)
           # Handle frozen strings by creating a mutable copy
           processed_xml = if xml.frozen?
@@ -54,7 +58,7 @@ module Moxml
 
           bridge = REXMLSAX2Bridge.new(handler)
 
-          xml_string = xml.respond_to?(:read) ? xml.read : xml.to_s
+          xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s
           source = ::REXML::IOSource.new(StringIO.new(xml_string))
 
           parser = ::REXML::Parsers::SAX2Parser.new(source)
@@ -77,6 +81,14 @@ module Moxml
           ::REXML::Text.new(content.to_s, true, nil)
         end
 
+        def create_native_entity_reference(name)
+          ::Moxml::Adapter::CustomizedRexml::EntityReference.new(name)
+        end
+
+        def entity_reference_name(node)
+          node.name if node.is_a?(::Moxml::Adapter::CustomizedRexml::EntityReference)
+        end
+
         def create_native_cdata(content, _owner_doc = nil)
           ::REXML::CData.new(content.to_s)
         end
@@ -124,6 +136,7 @@ module Moxml
           when ::REXML::Instruction then :processing_instruction
           when ::REXML::DocType then :doctype
           when ::REXML::XMLDecl then :declaration
+          when ::Moxml::Adapter::CustomizedRexml::EntityReference then :entity_reference
           else :unknown
           end
         end
@@ -149,13 +162,15 @@ module Moxml
         end
 
         def duplicate_node(node)
-          # Make a complete duplicate of the node
-          # https://stackoverflow.com/questions/23878384/why-the-original-element-got-changed-when-i-modify-the-copy-created-by-dup-meth
-          Marshal.load(Marshal.dump(node))
+          if node.respond_to?(:deep_clone)
+            node.deep_clone
+          else
+            Marshal.load(Marshal.dump(node))
+          end
         end
 
         def children(node)
-          return [] unless node.respond_to?(:children)
+          return [] unless node.is_a?(::REXML::Parent)
 
           # Get all children and filter out empty text nodes between elements
           result = node.children.reject do |child|
@@ -164,6 +179,10 @@ module Moxml
               !(child.next_sibling.nil? && child.previous_sibling.nil?)
           end
 
+          # Include any EntityReference wrappers stored alongside native children
+          entity_refs = attachments.get(node, :entity_refs)
+          result.concat(entity_refs) if entity_refs
+
           # Ensure uniqueness by object_id to prevent duplicates
           result.uniq(&:object_id)
         end
@@ -229,7 +248,7 @@ module Moxml
         end
 
         def attributes(element)
-          return [] unless element.respond_to?(:attributes)
+          return [] unless element.is_a?(::REXML::Element)
 
           # Only return non-namespace attributes
           element.attributes.values
@@ -273,18 +292,33 @@ module Moxml
         def add_child(element, child)
           # Special handling for declarations on REXML documents
           if element.is_a?(::REXML::Document) && child.is_a?(::REXML::XMLDecl)
-            # Set document's xml_decl directly
-            element.instance_variable_set(:@xml_declaration, child)
+            # Track declaration state in attachment map
+            attachments.set(element, :xml_declaration, child)
           end
 
           case child
           when String
             element.add_text(child)
+            append_child_sequence(element, :native)
+          when ::Moxml::Adapter::CustomizedRexml::EntityReference
+            # REXML doesn't support custom node types in its tree.
+            # Store alongside native children via attachment map.
+            refs = attachments.get(element, :entity_refs) || []
+            refs << child
+            attachments.set(element, :entity_refs, refs)
+            append_child_sequence(element, :eref)
           else
             element.add(child)
+            append_child_sequence(element, :native)
           end
         end
 
+        def append_child_sequence(element, type)
+          seq = attachments.get(element, :child_sequence) || []
+          seq << type
+          attachments.set(element, :child_sequence, seq)
+        end
+
         def add_previous_sibling(node, sibling)
           parent = node.parent
           # caveat: Rexml fails if children belong to the same parent and are already in a correct order
@@ -303,8 +337,8 @@ module Moxml
         def remove(node)
           # Special handling for declarations on REXML documents
           if node.is_a?(::REXML::XMLDecl) && node.parent.is_a?(::REXML::Document)
-            # Clear document's xml_declaration when removing declaration
-            node.parent.instance_variable_set(:@xml_declaration, nil)
+            # Clear declaration state in attachment map
+            attachments.set(node.parent, :xml_declaration, nil)
           end
 
           node.remove
@@ -373,6 +407,8 @@ module Moxml
           case node
           when ::REXML::Text, ::REXML::CData
             node.value.to_s
+          when ::Moxml::Adapter::CustomizedRexml::EntityReference
+            ""
           when ::REXML::Element
             # Extract text recursively from all children to match other adapters
             extract_text_recursively(node)
@@ -428,7 +464,7 @@ module Moxml
         # add a namespace prefix to the element name AND a namespace definition
         def set_namespace(element, ns)
           prefix = ns.name.to_s.empty? ? "xmlns" : ns.name.to_s
-          if element.respond_to?(:add_namespace)
+          if element.is_a?(::REXML::Element)
             element.add_namespace(prefix,
                                   ns.value)
           end
@@ -556,11 +592,26 @@ module Moxml
           output.strip
         end
 
+        def has_declaration?(native_doc, wrapper)
+          xml_decl = attachments.get(native_doc, :xml_declaration)
+          if xml_decl.nil?
+            # Attachment key doesn't exist - check native doc or wrapper flag
+            if attachments.key?(native_doc, :xml_declaration)
+              # Explicitly set to nil (was removed)
+              false
+            else
+              wrapper.has_xml_declaration
+            end
+          else
+            true
+          end
+        end
+
         private
 
         def write_with_formatter(node, output, indent = 2)
           formatter = ::Moxml::Adapter::CustomizedRexml::Formatter.new(
-            indentation: indent, self_close_empty: false,
+            indentation: indent, self_close_empty: false, adapter: self,
           )
           formatter.write(node, output)
         end

data/lib/moxml/attribute.rb

@@ -45,6 +45,9 @@ module Moxml
 
     def remove
       adapter.remove_attribute(element, name)
+      if @parent_node.is_a?(Moxml::Element)
+        @parent_node.invalidate_attribute_cache!
+      end
       self
     end