moxml 0.1.26 → 0.3.0

data/lib/moxml/adapter/oga.rb

@@ -5,6 +5,16 @@ require "oga"
 module Moxml
   module Adapter
     class Oga < Base
+      # Trigger autoloads that prepend override modules onto Oga's
+      # native classes before any parse / read runs.
+      # - EntityDecoderOverride: replace Oga 3.4's multi-pass decoder
+      #   with a single-pass decoder on Oga::EntityDecoder.
+      # - RawValueOverride: route Attribute#value / Text#text through
+      #   the NativeAttachment sidecar so user-authored values bypass
+      #   the lazy decoder and are returned verbatim.
+      ::Moxml::Adapter::CustomizedOga::EntityDecoderOverride
+      ::Moxml::Adapter::CustomizedOga::RawValueOverride
+
       class << self
         def attachments
           @attachments ||= Moxml::NativeAttachment.new
@@ -30,30 +40,48 @@ module Moxml
             )
           end
 
+          # Oga parses multiple root elements leniently; the moxml
+          # contract requires a single root. to_a because the vendored
+          # fork's NodeSet#count ignores its block.
+          roots = native_doc.children.to_a.count do |child|
+            child.instance_of?(::Oga::XML::Element)
+          end
+          if roots > 1
+            raise Moxml::ParseError.new(
+              "multiple root elements",
+              source: xml.is_a?(String) ? xml[0..100] : nil,
+            )
+          end
+
           ctx = _context || Context.new(:oga)
-          DocumentBuilder.new(ctx).build(native_doc)
+          doc = Document.new(native_doc, ctx)
+          Entity::Restorer.new(doc).run if ctx.config.restore_entities
+          doc
         end
 
-        # SAX parsing implementation for Oga
+        # SAX parsing implementation for Oga.
+        #
+        # Driven off `Oga.parse_xml` plus a DOM walk because Oga 3.4's
+        # native SAX parser decodes `on_text` content before delivery and
+        # exposes no hook to override. The prepended EntityDecoderOverride
+        # ensures `node.text` invoked during the walk produces the correct
+        # single-pass decode, so no separate entity pass is needed here.
+        # Trade-off: peak memory scales with document size (Oga 3.4 is the
+        # final release of an unmaintained gem; the trade is accepted).
         #
         # @param xml [String, IO] XML to parse
         # @param handler [Moxml::SAX::Handler] Moxml SAX handler
         # @return [void]
         def sax_parse(xml, handler)
-          bridge = OgaSAXBridge.new(handler)
-
           xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s
+          native_doc = ::Oga.parse_xml(xml_string)
 
-          # Manually call start_document (Oga doesn't)
-          handler.on_start_document
-
-          ::Oga.sax_parse_xml(bridge, xml_string)
-
-          # Manually call end_document (Oga doesn't)
-          handler.on_end_document
+          bridge = OgaSAXBridge.new(handler)
+          bridge.on_start_document
+          native_doc.children.each { |child| bridge.emit(child) }
+          bridge.on_end_document
         rescue StandardError => e
-          error = Moxml::ParseError.new(e.message)
-          handler.on_error(error)
+          handler.on_error(Moxml::ParseError.new(e.message))
         end
 
         def create_document(_native_doc = nil)
@@ -65,7 +93,14 @@ module Moxml
         end
 
         def create_native_text(content, _owner_doc = nil)
-          ::Oga::XML::Text.new(text: preprocess_entities(content))
+          processed = preprocess_entities(content)
+          text = ::Oga::XML::Text.new(text: processed)
+          # Oga::XML::Text.new stores the value via ivar, bypassing the
+          # RawValueOverride setter. Set the sidecar explicitly so reads
+          # return the user-supplied value verbatim rather than running
+          # it through the lazy decoder.
+          attachments.set(text, :raw_text, processed)
+          text
         end
 
         def create_native_entity_reference(name)
@@ -136,6 +171,7 @@ module Moxml
 
         def set_namespace(element, ns_or_string)
           element.namespace_name = ns_or_string.to_s
+          element
         end
 
         def namespace(element)
@@ -218,6 +254,38 @@ module Moxml
           node.parent if node.is_a?(::Oga::XML::Node)
         end
 
+        # Oga's Node#dup shallow-copies the ivars, leaving attributes
+        # and children shared with the original; the public dup
+        # contract needs a full deep copy.
+        def duplicate_node(node)
+          case node
+          when ::Oga::XML::Element
+            copy = ::Oga::XML::Element.new(name: node.name)
+            copy.namespace_name = node.namespace_name if node.namespace_name
+            node.attributes.each do |attr|
+              copy.add_attribute(::Oga::XML::Attribute.new(
+                                   name: attr.name,
+                                   namespace_name: attr.namespace_name,
+                                   value: attr.value,
+                                 ))
+            end
+            node.children.each do |child|
+              copy.children << duplicate_node(child)
+            end
+            copy
+          when ::Oga::XML::Text
+            ::Oga::XML::Text.new(text: node.text)
+          when ::Oga::XML::Cdata
+            ::Oga::XML::Cdata.new(text: node.text)
+          when ::Oga::XML::Comment
+            ::Oga::XML::Comment.new(text: node.text)
+          when ::Oga::XML::ProcessingInstruction
+            ::Oga::XML::ProcessingInstruction.new(name: node.name, text: node.text)
+          else
+            node.dup
+          end
+        end
+
         def next_sibling(node)
           node.next
         end
@@ -257,11 +325,15 @@ module Moxml
                                                    2)
           end
 
+          processed = preprocess_entities(value.to_s)
           attr = ::Oga::XML::Attribute.new(
             name: name.to_s,
             namespace_name: namespace_name,
-            value: preprocess_entities(value.to_s),
+            value: processed,
           )
+          # See create_native_text: Attribute.new bypasses the override
+          # setter, so populate the sidecar here.
+          attachments.set(attr, :raw_value, processed)
           element.add_attribute(attr)
         end
 
@@ -270,7 +342,8 @@ module Moxml
         end
 
         def get_attribute_value(element, name)
-          element[name.to_s]
+          attr = element.attribute(name.to_s)
+          attr&.value
         end
 
         def remove_attribute(element, name)
@@ -278,6 +351,12 @@ module Moxml
           element.attributes.delete(attr) if attr
         end
 
+        def remove_attribute_native(attr)
+          element = attr.element
+          element&.attributes&.delete(attr)
+          attr
+        end
+
         def add_child(element, child_or_text)
           child =
             if child_or_text.is_a?(String)
@@ -438,8 +517,10 @@ module Moxml
         end
 
         def xpath(node, expression, namespaces = nil)
-          node.xpath(expression, {},
-                     namespaces: namespaces&.transform_keys(&:to_s)).to_a
+          result = node.xpath(expression, {},
+                              namespaces: namespaces&.transform_keys(&:to_s))
+          # Adapter contract: Array<native> | scalar
+          result.is_a?(Enumerable) ? result.to_a : result
         rescue ::LL::ParserError => e
           raise Moxml::XPathError.new(
             e.message,
@@ -528,50 +609,53 @@ module Moxml
           ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(node).to_xml
         end
       end
-    end
 
-    # Bridge between Oga SAX and Moxml SAX
-    #
-    # Translates Oga SAX events to Moxml::SAX::Handler events.
-    # Oga has different event naming and namespace as first param.
-    #
-    # @private
-    class OgaSAXBridge
-      include Moxml::SAX::NamespaceSplitter
-
-      def initialize(handler)
-        @handler = handler
-      end
+      # Bridge between a parsed Oga DOM and Moxml SAX events.
+      #
+      # @private
+      class OgaSAXBridge
+        include Moxml::SAX::NamespaceSplitter
 
-      # Oga: on_element(namespace, name, attributes)
-      # namespace may be nil
-      # attributes is an array of [name, value] pairs
-      def on_element(namespace, name, attributes)
-        element_name = namespace ? "#{namespace}:#{name}" : name
-        attr_hash, ns_hash = split_attributes_and_namespaces(attributes)
-        @handler.on_start_element(element_name, attr_hash, ns_hash)
-      end
+        def initialize(handler)
+          @handler = handler
+        end
 
-      # Oga: after_element(namespace, name)
-      def after_element(namespace, name)
-        element_name = namespace ? "#{namespace}:#{name}" : name
-        @handler.on_end_element(element_name)
-      end
+        def on_start_document
+          @handler.on_start_document
+        end
 
-      def on_text(text)
-        @handler.on_characters(text)
-      end
+        def on_end_document
+          @handler.on_end_document
+        end
 
-      def on_cdata(text)
-        @handler.on_cdata(text)
-      end
+        # Walk a parsed Oga node and emit Moxml SAX events.
+        def emit(node)
+          case node
+          when ::Oga::XML::Element
+            element_name = qualified_name(node.namespace_name, node.name)
+            pairs = node.attributes.map do |a|
+              [qualified_name(a.namespace_name, a.name), a.value]
+            end
+            attrs, namespaces = split_attributes_and_namespaces(pairs)
+            @handler.on_start_element(element_name, attrs, namespaces)
+            node.children.each { |c| emit(c) }
+            @handler.on_end_element(element_name)
+          when ::Oga::XML::Text
+            @handler.on_characters(node.text)
+          when ::Oga::XML::Cdata
+            @handler.on_cdata(node.text)
+          when ::Oga::XML::Comment
+            @handler.on_comment(node.text)
+          when ::Oga::XML::ProcessingInstruction
+            @handler.on_processing_instruction(node.name, node.text || "")
+          end
+        end
 
-      def on_comment(text)
-        @handler.on_comment(text)
-      end
+        private
 
-      def on_processing_instruction(name, text)
-        @handler.on_processing_instruction(name, text || "")
+        def qualified_name(namespace, local)
+          namespace ? "#{namespace}:#{local}" : local
+        end
       end
     end
   end

data/lib/moxml/adapter/ox.rb

@@ -51,7 +51,7 @@ module Moxml
             )
           end
 
-          ctx = _context || Context.new(:ox)
+          ctx = _context || Context.new(context_adapter_name)
           Document.new(native_doc, ctx)
         end
 
@@ -147,7 +147,7 @@ module Moxml
         end
 
         def set_namespace(element, ns)
-          return unless element.is_a?(::Ox::Element) || element.is_a?(::Ox::Node)
+          return element 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
@@ -157,7 +157,7 @@ module Moxml
           end
           element.name = [prefix,
                           element.name.delete_prefix("xmlns:")].compact.join(":")
-          namespace(element)
+          element
         end
 
         def namespace(element)
@@ -167,6 +167,19 @@ module Moxml
             elsif element.name.include?(":")
               element.name.split(":").first
             end
+
+          # Unprefixed attributes are in no namespace — the default
+          # namespace declaration does not apply to attribute names
+          # (Namespaces 1.0 §5.2). Unprefixed elements DO take it.
+          return nil if element.is_a?(::Moxml::Adapter::CustomizedOx::Attribute) && prefix.nil?
+
+          # Namespaces 1.0 §4: xml is prebound; no declaration required.
+          if prefix == "xml"
+            return ::Moxml::Adapter::CustomizedOx::Namespace.new(
+              prefix, Moxml::AttributeResolver::XML_NAMESPACE_URI, element
+            )
+          end
+
           attr_name = ["xmlns", prefix].compact.join(":")
 
           ([element] + ancestors(element)).each do |node|
@@ -341,6 +354,7 @@ module Moxml
           element = attribute.parent
           element.attributes.delete(old_name)
           element.attributes[name] = attribute.value
+          attribute
         end
 
         def set_attribute_value(attribute, new_value)
@@ -348,9 +362,16 @@ module Moxml
             # Ox converts all values to strings
             remove_attribute(attribute.parent, attribute.name)
           else
+            element = attribute.parent
+            # Rekey by the expanded name (Ox hash keys carry the
+            # prefix) and collapse any symbol/string spelling of the
+            # same key, or a stale symbol key shadows the new value.
+            expanded = attribute.expanded_name
+            element.attributes.delete(expanded.to_sym)
+            element.attributes[expanded] = new_value
             attribute.value = new_value
-            attribute.parent.attributes[attribute.name] = new_value
           end
+          attribute
         end
 
         def get_attribute(element, name)
@@ -378,6 +399,14 @@ module Moxml
           element.attributes.delete(name.to_s.to_sym)
         end
 
+        def remove_attribute_native(attribute)
+          expanded = attribute.expanded_name
+          element = attribute.parent
+          element.attributes.delete(expanded)
+          element.attributes.delete(expanded.to_sym)
+          attribute
+        end
+
         def add_child(element, child)
           if element.is_a?(::Ox::Document) && child.is_a?(::Ox::Instruct) && child.target == "xml"
             element.attributes ||= {}
@@ -504,6 +533,7 @@ module Moxml
           case node
           when String then node.to_s
           when ::Moxml::Adapter::CustomizedOx::Text then node.value
+          when ::Ox::CData then node.value.to_s
           when ::Moxml::Adapter::CustomizedOx::EntityReference then ""
           else
             return "" unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
@@ -601,34 +631,34 @@ module Moxml
           matches.last&.first
         end
 
+        # XPath runs through Moxml's pure-Ruby XPath 1.0 engine (shared
+        # with HeadedOx and Leptris). Ox's locate() only covers a
+        # small XPath subset; the engine provides all axes,
+        # predicates, functions and variables.
         def xpath(node, expression, namespaces = {})
-          # Translate common XPath patterns to Ox locate() syntax
-          locate_expr = translate_xpath_to_locate(expression, namespaces)
-
-          # Ox's locate() works differently on documents vs elements
-          # For relative descendant searches on elements, we need special handling
-          if expression.start_with?(".//") && node.is_a?(::Ox::Element)
-            # Manually search descendants for relative paths from elements
-            element_name = locate_expr.sub("?/", "")
-            results = []
-            traverse(node) do |n|
-              next unless n.is_a?(::Ox::Element)
-
-              results << n if n.name == element_name || element_name.empty?
-            end
-            return results.map do |n|
-              patch_node(n, find_parent_in_tree(n, node))
-            end
+          wrapped = if node.is_a?(Moxml::Node)
+                      node
+                    else
+                      Moxml::Node.wrap(node, Context.new(context_adapter_name))
+                    end
+
+          ast = XPath::Parser.parse(expression)
+          proc = XPath::Compiler.compile_with_cache(ast, namespaces: namespaces)
+          result = proc.call(wrapped)
+
+          case result
+          when Array
+            dedupe_natives(result.map do |n|
+              n.is_a?(Moxml::Node) ? n.native : n
+            end)
+          when NodeSet
+            dedupe_natives(result.to_a.map(&:native))
+          else
+            result
           end
-
-          # Use Ox's locate method for other cases
-          results = node.locate(locate_expr)
-
-          # Wrap results and set their parents by finding them in the tree
-          results.map { |n| patch_node(n, find_parent_in_tree(n, node)) }
         rescue StandardError => e
           raise Moxml::XPathError.new(
-            "XPath translation failed: #{e.message}",
+            "XPath execution failed: #{e.message}",
             expression: expression,
             adapter: "Ox",
             node: node,
@@ -636,7 +666,32 @@ module Moxml
         end
 
         def at_xpath(node, expression, namespaces = {})
-          xpath(node, expression, namespaces)&.first
+          result = xpath(node, expression, namespaces)
+          result.is_a?(Array) ? result.first : result
+        end
+
+        def xpath_supported?
+          true
+        end
+
+        # Identity-based dedup: uniq's value equality would collapse
+        # equal String text nodes.
+        def dedupe_natives(natives)
+          seen = {}
+          natives.select do |native|
+            id = native.object_id
+            if seen[id]
+              false
+            else
+              seen[id] = true
+            end
+          end
+        end
+
+        # Adapter name used when wrapping bare native nodes; kept
+        # overridable so HeadedOx wraps into its own adapter.
+        def context_adapter_name
+          :ox
         end
 
         def serialize(node, options = {})
@@ -644,7 +699,7 @@ module Moxml
           # back-reference, but that makes it unknown to Ox.dump's XML emitter,
           # which then falls back to generic object marshalling. Short-circuit
           # here with proper XML escaping.
-          return escape_xml_text(node.value) if node.is_a?(CustomizedOx::Text)
+          return XmlEmitter.escape_text(node.value) if node.is_a?(CustomizedOx::Text)
 
           needs_custom = needs_custom_serialize?(node)
 
@@ -782,10 +837,7 @@ module Moxml
               version = node[:version] || "1.0"
               encoding = resolve_decl_attr(node, :encoding, options[:encoding])
               standalone = resolve_decl_attr(node, :standalone, nil)
-              output << "<?xml version=\"#{version}\""
-              output << " encoding=\"#{encoding}\"" if encoding
-              output << " standalone=\"#{standalone}\"" if standalone
-              output << "?>"
+              output << XmlEmitter.declaration_xml(version, encoding, standalone)
             end
             (node.nodes || []).each do |child|
               output << serialize_node_custom(child)
@@ -799,10 +851,10 @@ module Moxml
         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 String then XmlEmitter.escape_text(node)
+          when ::Moxml::Adapter::CustomizedOx::Text then XmlEmitter.escape_text(node.value)
           when ::Moxml::Adapter::CustomizedOx::EntityReference then "&#{node.name};"
-          when ::Ox::CData then serialize_cdata(node.value)
+          when ::Ox::CData then XmlEmitter.cdata(node.value)
           when ::Ox::Comment then "<!--#{node.value}-->"
           when ::Ox::Instruct then "<?#{node.target} #{node.value || ''}?>"
           when ::Ox::DocType then "<!DOCTYPE #{node.value}>"
@@ -813,7 +865,7 @@ module Moxml
         def serialize_element_custom(elem)
           output = "<#{elem.name}"
           elem.attributes.each do |name, value|
-            output << " #{name}=\"#{escape_xml_attribute(value.to_s)}\""
+            output << " #{name}=\"#{XmlEmitter.escape_attribute(value)}\""
           end
 
           if elem.nodes.nil? || elem.nodes.empty?
@@ -828,104 +880,6 @@ module Moxml
           output << "</#{elem.name}>"
           output
         end
-
-        def serialize_cdata(content)
-          escaped = content.gsub("]]>", "]]]]><![CDATA[>")
-          "<![CDATA[#{escaped}]]>"
-        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]
-        # Note: Ox locate() doesn't support namespace prefixes in the path
-        def translate_xpath_to_locate(xpath, namespaces = {})
-          expr = xpath.dup
-
-          # Strip namespace prefixes from element names
-          # XPath: //ns:element → locate: element
-          if namespaces && !namespaces.empty?
-            namespaces.each_key do |prefix|
-              expr = expr.gsub("/#{prefix}:", "/")
-              expr = expr.gsub("/*#{prefix}:", "/*")
-              expr = expr.gsub("//*#{prefix}:", "//")
-              expr = expr.gsub("//#{prefix}:", "//")
-              expr = expr.gsub("///#{prefix}:", "///")
-            end
-          end
-
-          # Remove any remaining namespace prefixes
-          # Use possessive quantifier to prevent ReDoS
-          expr = expr.gsub(/[a-zA-Z_][\w-]*+:/, "")
-
-          # Remove attribute predicates for now - we'll filter manually
-          # Save the attribute name if present
-          expr = expr.gsub(/\[@(\w+)\]/, "")
-
-          # XPath: //element → locate: ?/element (any depth)
-          # Note: In Ox, ?/ means "any path"
-          expr = expr.sub(%r{^//}, "?/") if expr.start_with?("//")
-
-          # XPath: .//element → locate: ?/element (relative any depth)
-          # For relative paths from an element, we still use ?/ which searches
-          # descendants
-          expr = expr.sub(%r{^\.//}, "?/") if expr.start_with?(".//")
-
-          # XPath: /root/child → locate: root/child (absolute path)
-          # Remove leading / for Ox
-          expr = expr.sub(%r{^/}, "")
-
-          # XPath: ./element → locate: element (direct child, just remove ./)
-          expr.sub(%r{^\./}, "")
-        end
-
-        # Find the actual parent of a node by searching the tree
-        def find_parent_in_tree(target_node, search_root)
-          # Start from the document root if we have a document
-          root = search_root.is_a?(::Ox::Document) ? search_root : document(search_root)
-
-          result = nil
-          traverse(root) do |node|
-            next unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
-
-            node.nodes&.each do |child|
-              if child.equal?(target_node)
-                result = node
-                break
-              end
-            end
-            break if result
-          end
-          result
-        end
-
-        def traverse(node, &block)
-          return unless node
-
-          yield node
-          return unless node.is_a?(::Ox::Element) || node.is_a?(::Ox::Document)
-
-          node.nodes&.each { |child| traverse(child, &block) }
-        end
       end
     end
 
@@ -948,7 +902,9 @@ module Moxml
 
       # Ox delivers attributes AFTER start_element
       def attr(name, value)
-        @pending_attrs[name] = value
+        # Attributes arriving before the first start_element belong
+        # to the XML declaration, not to any element
+        @pending_attrs[name.to_s] = value if @pending_element_name
       end
 
       # Called when element starts (but attributes come AFTER this)