moxml 0.1.26 → 0.3.0

data/lib/moxml/adapter/libxml.rb

@@ -8,7 +8,6 @@ module Moxml
   module Adapter
     class Libxml < Base
       autoload :EntityRefRegistry, "moxml/adapter/libxml/entity_ref_registry"
-      autoload :EntityRestorer, "moxml/adapter/libxml/entity_restorer"
 
       # Wrapper class to store DOCTYPE information
       class DoctypeWrapper
@@ -28,15 +27,7 @@ module Moxml
         end
 
         def to_xml
-          output = "<!DOCTYPE #{@name}"
-          if @external_id && !@external_id.empty?
-            output << " PUBLIC \"#{@external_id}\""
-            output << " \"#{@system_id}\"" if @system_id
-          elsif @system_id && !@system_id.empty?
-            output << " SYSTEM \"#{@system_id}\""
-          end
-          output << ">"
-          output
+          XmlEmitter.doctype_xml(@name, @external_id, @system_id)
         end
       end
 
@@ -57,6 +48,7 @@ module Moxml
 
       WRAPPER_NODE_TYPE_MAP = {
         DoctypeWrapper => :doctype,
+        CustomizedLibxml::Declaration => :declaration,
         CustomizedLibxml::Element => :element,
         CustomizedLibxml::Text => :text,
         CustomizedLibxml::Cdata => :cdata,
@@ -91,7 +83,7 @@ module Moxml
           xml_string = preprocess_entities(xml_string)
 
           # Extract DOCTYPE before parsing
-          doctype_match = xml_string.match(/<!DOCTYPE\s+(\S+)(?:\s+PUBLIC\s+"([^"]+)"\s+"([^"]+)"|  \s+SYSTEM\s+"([^"]+)")?\s*>/i)
+          doctype_match = xml_string.match(/<!DOCTYPE\s+([^\s>]+)(?:\s+PUBLIC\s+"([^"]+)"\s+"([^"]+)"|\s+SYSTEM\s+"([^"]+)")?\s*>/i)
 
           native_doc = begin
             # Handle both string and file inputs
@@ -128,10 +120,7 @@ module Moxml
 
           ctx = _context || Context.new(:libxml)
           # Single parse path: wrap libxml's already-complete C-parsed tree
-          # directly (same pattern as nokogiri/ox). The previous
-          # DocumentBuilder.build path walked the entire parsed tree and
-          # re-added every node to a fresh moxml-managed document, which
-          # made parse O(N) Ruby work on top of an already-complete parse.
+          # directly (same pattern as the other adapters).
           # Doctype/declaration/PI attachments set above remain on
           # native_doc, so the serialize path still sees them.
           #
@@ -141,7 +130,7 @@ module Moxml
           # path; the restoration walk is just one of potentially several
           # post-processing steps and doesn't fork the construction.
           doc = Document.new(native_doc, ctx)
-          EntityRestorer.new(doc).run if ctx.config.restore_entities
+          Entity::Restorer.new(doc).run if ctx.config.restore_entities
           doc
         end
 
@@ -226,7 +215,7 @@ module Moxml
           return :unknown unless node
 
           # Fast path: native libxml nodes are the vast majority during
-          # parse traversal (DocumentBuilder visits raw libxml children).
+          # parse traversal (wrapping visits raw libxml children).
           # Skip the wrapper checks below for them.
           if node.is_a?(::LibXML::XML::Node)
             return NATIVE_NODE_TYPE_MAP[node.node_type] || :unknown
@@ -379,6 +368,11 @@ module Moxml
           native_doc&.root
         end
 
+        def line_number(node)
+          native = unpatch_node(node)
+          native.is_a?(::LibXML::XML::Node) ? native.line_num : nil
+        end
+
         def attributes(element)
           native_elem = unpatch_node(element)
           return [] unless native_elem
@@ -437,9 +431,13 @@ module Moxml
               native_elem.attributes.get_attribute(name_str)
             end
           else
-            # Regular attribute without namespace
-            native_elem[name_str] = value_str
-            native_elem.attributes.get_attribute(name_str)
+            # node[]= is ambiguous when a namespace-bound attribute
+            # shares the local name (it clobbers that attribute);
+            # create or replace the no-namespace attribute explicitly.
+            native_elem.each_attr do |attr|
+              attr.remove! if !attr.ns && attr.name == name_str
+            end if native_elem.attributes?
+            ::LibXML::XML::Attr.new(native_elem, name_str, value_str)
           end
         end
 
@@ -467,30 +465,46 @@ module Moxml
           native_elem = unpatch_node(element)
           return nil unless native_elem
 
-          # Try to get the attribute with the given name (handles namespaced attrs)
-          value = native_elem[name.to_s]
-          return value if value
-
-          # If name contains ':', try to get as namespaced attribute
-          if name.to_s.include?(":")
-            prefix, local_name = name.to_s.split(":", 2)
+          name_s = name.to_s
+          if name_s.include?(":")
+            prefix, local_name = name_s.split(":", 2)
             # Try to find attribute by namespace
             if native_elem.attributes?
               native_elem.each_attr do |attr|
-                if attr.name == local_name || attr.name == name.to_s
+                if [local_name, name_s].include?(attr.name)
                   # Check if attribute's namespace matches the prefix
                   if attr.ns && attr.ns.prefix == prefix
                     return attr.value
-                  elsif attr.name == name.to_s
+                  elsif attr.name == name_s
                     # Fallback: attribute name includes the prefix
                     return attr.value
                   end
                 end
               end
             end
+
+            return nil
           end
 
-          nil
+          # Bare name: node[name_s] is ambiguous when a namespaced
+          # attribute shares the local name (issue #94), so prefer the
+          # namespace-less attribute explicitly.
+          if native_elem.attributes?
+            namespaced_value = nil
+            native_elem.each_attr do |attr|
+              next if attr.name.to_s.start_with?("xmlns")
+              next unless attr.name == name_s
+
+              if attr.ns.nil?
+                return attr.value
+              elsif namespaced_value.nil?
+                namespaced_value = attr.value
+              end
+            end
+            return namespaced_value unless namespaced_value.nil?
+          end
+
+          native_elem[name_s]
         end
 
         def remove_attribute(element, name)
@@ -502,6 +516,10 @@ module Moxml
           attr&.remove!
         end
 
+        def remove_attribute_native(attr)
+          attr&.remove!
+        end
+
         def set_attribute_name(attribute, new_name)
           # LibXML attributes cannot be renamed directly
           # We must work at the element level
@@ -730,26 +748,52 @@ module Moxml
 
         def set_text_content(node, content)
           native_node = unpatch_node(node)
-          native_node.content = content.to_s if native_node
+          return unless native_node.is_a?(::LibXML::XML::Node)
+
+          # Text wrapper: swap with new_text to preserve verbatim storage.
+          # Element wrapper: let libxml manage the child text node.
+          if native_node.text?
+            replace_native_verbatim(node, ::LibXML::XML::Node.new_text(content.to_s))
+          else
+            native_node.content = content.to_s
+          end
         end
 
-        def cdata_content(node)
-          native_node = unpatch_node(node)
-          content = native_node&.content
-          # LibXML may HTML-escape CDATA content, un-escape it
-          return nil unless content
+        # Replace `old_native` with `fresh`, preserving position. Both
+        # neighbor pointers are set explicitly to match `replace`'s
+        # semantics (see #replace above).
+        def swap_native_in_place(old_native, fresh)
+          parent = old_native.parent
+          return if parent.nil?
+
+          prev_sibling = old_native.prev
+          next_sibling = old_native.next
+          old_native.remove!
+          prev_sibling.next = fresh if prev_sibling
+          next_sibling.prev = fresh if next_sibling
+          parent << fresh unless prev_sibling || next_sibling
+        end
+        private :swap_native_in_place
+
+        # libxml-ruby's node.content= pre-escapes; building a fresh node via
+        # new_<kind> stores content verbatim. Swap in place and re-point the
+        # wrapper.
+        def replace_native_verbatim(node, fresh)
+          native = unpatch_node(node)
+          return unless native.is_a?(::LibXML::XML::Node)
+
+          swap_native_in_place(native, fresh)
+          node.replace_native!(fresh) if node.is_a?(CustomizedLibxml::Node)
+        end
+        private :replace_native_verbatim
 
-          content.gsub("&quot;", '"')
-            .gsub("&apos;", "'")
-            .gsub("&lt;", "<")
-            .gsub("&gt;", ">")
-            .gsub("&amp;", "&")
+        def cdata_content(node)
+          # libxml stores CDATA payload verbatim; no decoding needed.
+          unpatch_node(node)&.content
         end
 
         def set_cdata_content(node, content)
-          native_node = unpatch_node(node)
-          # CDATA content should NOT be escaped
-          native_node.content = content.to_s if native_node
+          replace_native_verbatim(node, ::LibXML::XML::Node.new_cdata(content.to_s))
         end
 
         def comment_content(node)
@@ -758,8 +802,7 @@ module Moxml
         end
 
         def set_comment_content(node, content)
-          native_node = unpatch_node(node)
-          native_node.content = content.to_s if native_node
+          replace_native_verbatim(node, ::LibXML::XML::Node.new_comment(content.to_s))
         end
 
         def processing_instruction_target(node)
@@ -768,22 +811,18 @@ module Moxml
         end
 
         def processing_instruction_content(node)
-          native_node = unpatch_node(node)
-          content = native_node&.content
-          # LibXML may HTML-escape the content, un-escape it
-          return nil unless content
-
-          content.gsub("&quot;", '"')
-            .gsub("&apos;", "'")
-            .gsub("&lt;", "<")
-            .gsub("&gt;", ">")
-            .gsub("&amp;", "&")
+          # XML 1.0 §2.6: PI content is verbatim — no entity resolution.
+          unpatch_node(node)&.content
         end
 
         def set_processing_instruction_content(node, content)
           native_node = unpatch_node(node)
-          # Store raw content - LibXML will escape it
-          native_node.content = content.to_s if native_node
+          return unless native_node.is_a?(::LibXML::XML::Node)
+
+          replace_native_verbatim(
+            node,
+            ::LibXML::XML::Node.new_pi(native_node.name, content.to_s),
+          )
         end
 
         def create_native_namespace(element, prefix, uri)
@@ -804,9 +843,10 @@ module Moxml
 
         def set_namespace(element, ns)
           native_elem = unpatch_node(element)
-          return unless native_elem && ns
+          return element unless native_elem
 
-          native_elem.namespaces.namespace = ns
+          native_elem.namespaces.namespace = ns if ns
+          element
         end
 
         def namespace(element)
@@ -867,14 +907,18 @@ module Moxml
           # LibXML requires ALL prefixes in the XPath to be registered
           ns_context = build_xpath_namespaces(native_node, namespaces)
 
-          results = if ns_context.empty?
-                      native_node.find(expression).to_a
-                    else
-                      native_node.find(expression, ns_context).to_a
-                    end
+          found = if ns_context.empty?
+                    native_node.find(expression)
+                  else
+                    native_node.find(expression, ns_context)
+                  end
+
+          # find returns an XPath::Object for node results, scalars for
+          # count()/string()/boolean functions (adapter contract)
+          return found if found.is_a?(Float) || found.is_a?(String) ||
+            [true, false].include?(found)
 
-          # Wrap results
-          results.map { |n| patch_node(n) }
+          found.to_a.map { |n| patch_node(n) }
         rescue ::LibXML::XML::Error => e
           raise Moxml::XPathError.new(
             e.message,
@@ -987,7 +1031,7 @@ module Moxml
         end
 
         # Shallow duplication: copies the node itself (name, attrs, namespaces)
-        # but NOT its descendants. This is what DocumentBuilder needs — it
+        # but NOT its descendants (deep duplication composes this).
         # walks the source tree and re-adds children one at a time via
         # add_child, so a deep copy here would be done only to be stripped
         # by replace_children, then rebuilt — O(N²) waste on parse.
@@ -1013,7 +1057,8 @@ module Moxml
               node
             end
           when :element
-            shallow_duplicate_element(native_node)
+            # Public dup contract: a full deep copy of the subtree
+            deep_duplicate_node(native_node)
           when :text
             ::LibXML::XML::Node.new_text(native_node.content)
           when :cdata
@@ -1058,15 +1103,6 @@ module Moxml
           end
         end
 
-        def prepare_for_new_document(node, target_doc)
-          return node unless node && target_doc
-
-          # For LibXML, we need to duplicate ALL nodes to avoid
-          # document ownership issues. Simply importing doesn't work
-          # because nodes from the parsed document still have references.
-          duplicate_node(node)
-        end
-
         def has_declaration?(native_doc, wrapper)
           decl = attachments.get(native_doc, :declaration)
           if decl
@@ -1109,9 +1145,9 @@ module Moxml
 
               seen_ns[prefix] = true
               output << if prefix.nil? || prefix.empty?
-                          " xmlns=\"#{escape_xml(uri)}\""
+                          " xmlns=\"#{XmlEmitter.escape_attribute(uri)}\""
                         else
-                          " xmlns:#{prefix}=\"#{escape_xml(uri)}\""
+                          " xmlns:#{prefix}=\"#{XmlEmitter.escape_attribute(uri)}\""
                         end
             end
           end
@@ -1127,7 +1163,7 @@ module Moxml
                           else
                             attr.name
                           end
-              output << " #{attr_name}=\"#{escape_xml(attr.value)}\""
+              output << " #{attr_name}=\"#{XmlEmitter.escape_attribute(attr.value)}\""
             end
           end
 
@@ -1167,7 +1203,7 @@ module Moxml
           when ::LibXML::XML::Node::ELEMENT_NODE
             serialize_element(node)
           when ::LibXML::XML::Node::TEXT_NODE
-            escape_text(node.content)
+            XmlEmitter.escape_text(node.content)
           when ::LibXML::XML::Node::CDATA_SECTION_NODE
             "<![CDATA[#{node.content}]]>"
           when ::LibXML::XML::Node::COMMENT_NODE
@@ -1179,28 +1215,6 @@ module Moxml
           end
         end
 
-        def escape_text(text)
-          text.to_s
-            .gsub("&", "&amp;")
-            .gsub("<", "&lt;")
-            .gsub(">", "&gt;")
-        end
-
-        ESCAPE_XML_RE = /[&<>"]/
-        ESCAPE_XML_MAP = { "&" => "&amp;", "<" => "&lt;", ">" => "&gt;",
-                           '"' => "&quot;" }.freeze
-        private_constant :ESCAPE_XML_RE, :ESCAPE_XML_MAP
-
-        def escape_xml(text)
-          # One gsub pass with a Hash replacement allocates a single new
-          # string. The previous chained gsubs allocated three throwaway
-          # strings on every call (very hot for attribute-heavy XML).
-          str = text.is_a?(String) ? text : text.to_s
-          return str unless str.match?(ESCAPE_XML_RE)
-
-          str.gsub(ESCAPE_XML_RE, ESCAPE_XML_MAP)
-        end
-
         def import_and_add(doc, element, child)
           return unless element && child
 
@@ -1357,9 +1371,9 @@ module Moxml
 
         def format_ns_declaration(prefix, uri)
           if prefix.nil? || prefix.empty?
-            " xmlns=\"#{escape_xml(uri)}\""
+            " xmlns=\"#{XmlEmitter.escape_attribute(uri)}\""
           else
-            " xmlns:#{prefix}=\"#{escape_xml(uri)}\""
+            " xmlns:#{prefix}=\"#{XmlEmitter.escape_attribute(uri)}\""
           end
         end
 
@@ -1370,7 +1384,7 @@ module Moxml
             next if attr.name.start_with?("xmlns")
 
             attr_name = attr.ns&.prefix ? "#{attr.ns.prefix}:#{attr.name}" : attr.name
-            output << " #{attr_name}=\"#{escape_xml(attr.value)}\""
+            output << " #{attr_name}=\"#{XmlEmitter.escape_attribute(attr.value)}\""
           end
         end
 
@@ -1510,11 +1524,6 @@ module Moxml
           end
         end
 
-        def remove_indentation(xml_string)
-          # Remove all newlines and extra spaces between tags
-          xml_string.gsub(/>\s+</, "><").gsub(/\n\s*/, "")
-        end
-
         def collect_namespace_definitions(node)
           ns_defs = {}
 
@@ -1693,13 +1702,24 @@ module Moxml
           @handler.on_end_document
         end
 
-        def on_start_element(name, attributes)
-          attr_hash, ns_hash = split_attributes_and_namespaces(attributes)
-          @handler.on_start_element(name.to_s, attr_hash, ns_hash)
+        # libxml strips prefixes and namespace declarations from the
+        # plain on_start_element callback; the _ns variants carry
+        # them. The namespaces hash uses nil for the default
+        # declaration — the same key convention as every other
+        # bridge's split. Attribute name prefixes are lost by the
+        # binding in both callbacks (documented limitation).
+        def on_start_element_ns(name, attributes, prefix, _uri, namespaces)
+          normalized = (attributes || {}).map { |k, v| [k.to_s, v] }
+          attr_hash, = split_attributes_and_namespaces(normalized) do |v|
+            Moxml::Adapter::Base.decode_entities(v)
+          end
+          qualified = prefix ? "#{prefix}:#{name}" : name.to_s
+          @handler.on_start_element(qualified, attr_hash, namespaces || {})
         end
 
-        def on_end_element(name)
-          @handler.on_end_element(name.to_s)
+        def on_end_element_ns(name, prefix, _uri)
+          qualified = prefix ? "#{prefix}:#{name}" : name.to_s
+          @handler.on_end_element(qualified)
         end
 
         def on_characters(chars)

data/lib/moxml/adapter/nokogiri.rb

@@ -144,6 +144,7 @@ module Moxml
 
         def set_namespace(element, ns)
           element.namespace = ns
+          element
         end
 
         def namespace(element)
@@ -216,21 +217,36 @@ module Moxml
           document.is_a?(::Nokogiri::XML::Document) ? document.root : document.children.first
         end
 
-        def attribute_element(attr)
-          attr.parent
+        def line_number(node)
+          node.line
         end
 
-        def attributes(element)
-          element.attributes.values
+        def attribute_element(attr)
+          attr.parent
         end
 
         def set_attribute(element, name, value)
           element[name.to_s] = value.to_s
         end
 
+        def attributes(element)
+          # attribute_nodes, not attributes.values: the attributes Hash
+          # is keyed by local name, so xmi:type and type collide and
+          # one is silently dropped (issue #94).
+          element.attribute_nodes
+        end
+
         def get_attribute(element, name)
-          # attributes keys don't include attribute namespaces
-          element.attributes[name.to_s]
+          name_s = name.to_s
+          if name_s.include?(":")
+            prefix, local = name_s.split(":", 2)
+            href = element.namespace_definitions
+              .find { |ns| ns.prefix == prefix }&.href
+            element.attribute_with_ns(local, href)
+          else
+            element.attribute_with_ns(name_s, nil) ||
+              element.attributes[name_s]
+          end
         end
 
         def get_attribute_value(element, name)
@@ -360,7 +376,10 @@ module Moxml
         end
 
         def xpath(node, expression, namespaces = nil)
-          node.xpath(expression, namespaces).to_a
+          result = node.xpath(expression, namespaces)
+          # Adapter contract: Array<native> | scalar (count(),
+          # string-length(), boolean functions return scalars).
+          result.is_a?(Enumerable) ? result.to_a : result
         rescue ::Nokogiri::XML::XPath::SyntaxError => e
           raise Moxml::XPathError.new(
             e.message,
@@ -471,7 +490,9 @@ module Moxml
         end
 
         def start_element(name, attributes = [])
-          attr_hash, ns_hash = split_attributes_and_namespaces(attributes)
+          attr_hash, ns_hash = split_attributes_and_namespaces(attributes) do |v|
+            Moxml::Adapter::Base.decode_entities(v)
+          end
           @handler.on_start_element(name, attr_hash, ns_hash)
         end