moxml 0.1.7 → 0.1.9

data/lib/moxml/adapter/ox.rb

@@ -2,12 +2,13 @@
 
 require_relative "base"
 require "ox"
+require "stringio"
 require_relative "customized_ox/text"
 require_relative "customized_ox/attribute"
 require_relative "customized_ox/namespace"
 
 # insert :parent methods to all Ox classes inherit the Node class
-::Ox::Node.attr_accessor :parent
+Ox::Node.attr_accessor :parent
 module Moxml
   module Adapter
     class Ox < Base
@@ -29,12 +30,37 @@ module Moxml
               doc
             end
           rescue ::Ox::ParseError => e
-            raise Moxml::ParseError, e.message
+            raise Moxml::ParseError.new(
+              e.message,
+              source: xml.is_a?(String) ? xml[0..100] : nil,
+            )
           end
 
           DocumentBuilder.new(Context.new(:ox)).build(native_doc)
         end
 
+        # SAX parsing implementation for Ox
+        #
+        # @param xml [String, IO] XML to parse
+        # @param handler [Moxml::SAX::Handler] Moxml SAX handler
+        # @return [void]
+        def sax_parse(xml, handler)
+          # Create bridge that translates Ox SAX to Moxml SAX
+          bridge = OxSAXBridge.new(handler)
+
+          # Parse using Ox's SAX parser
+          xml_string = xml.respond_to?(:read) ? xml.read : xml.to_s
+
+          begin
+            ::Ox.sax_parse(bridge, StringIO.new(xml_string))
+            # Ox doesn't automatically call end_document, so we do it manually
+            bridge.end_document
+          rescue ::Ox::ParseError => e
+            error = Moxml::ParseError.new(e.message)
+            handler.on_error(error)
+          end
+        end
+
         def create_document(native_doc = nil)
           attrs = native_doc&.attributes || {}
           ::Ox::Document.new(**attrs)
@@ -60,7 +86,7 @@ module Moxml
 
         def create_native_doctype(name, external_id, system_id)
           ::Ox::DocType.new(
-            "#{name} PUBLIC \"#{external_id}\" \"#{system_id}\""
+            "#{name} PUBLIC \"#{external_id}\" \"#{system_id}\"",
           )
         end
 
@@ -87,7 +113,8 @@ module Moxml
         end
 
         def create_native_namespace(element, prefix, uri)
-          ns = ::Moxml::Adapter::CustomizedOx::Namespace.new(prefix, uri, element)
+          ns = ::Moxml::Adapter::CustomizedOx::Namespace.new(prefix, uri,
+                                                             element)
           set_attribute(element, ns.expanded_prefix, uri)
           ns
         end
@@ -97,8 +124,12 @@ module Moxml
 
           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(":")
+          if element.respond_to?(:attributes)
+            set_attribute(element, ns.expanded_prefix,
+                          ns.uri)
+          end
+          element.name = [prefix,
+                          element.name.delete_prefix("xmlns:")].compact.join(":")
           namespace(element)
         end
 
@@ -151,9 +182,14 @@ module Moxml
         end
 
         def node_name(node)
-          node.value
-        rescue StandardError
-          node.name
+          name = begin
+            node.value
+          rescue StandardError
+            node.name
+          end
+
+          # Strip namespace prefix if present
+          name.to_s.split(":", 2).last
         end
 
         def set_node_name(node, name)
@@ -172,8 +208,12 @@ module Moxml
           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 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
@@ -186,7 +226,8 @@ module Moxml
         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::Attribute then { node.name => node.value }
           when ::Moxml::Adapter::CustomizedOx::Text then node.value
           else node
@@ -230,15 +271,18 @@ module Moxml
         end
 
         def attributes(element)
-          return [] unless element.respond_to?(:attributes) && element.attributes
+          unless element.respond_to?(:attributes) && element.attributes
+            return []
+          end
 
-          element.attributes.map do |name, value|
-            next if name.start_with?("xmlns")
+          element.attributes.filter_map do |name, value|
+            next if name.to_s.start_with?("xmlns")
 
+            # Ensure value is passed correctly - Ox stores with symbol keys
             ::Moxml::Adapter::CustomizedOx::Attribute.new(
-              name, value, element
+              name.to_s, value, element
             )
-          end.compact
+          end
         end
 
         def attribute_element(attribute)
@@ -280,10 +324,15 @@ module Moxml
 
         def get_attribute(element, name)
           return unless element.respond_to?(:attributes) && element.attributes
-          return unless element.attributes.key?(name.to_s) || element.attributes.key?(name.to_s.to_sym)
+          unless element.attributes.key?(name.to_s) || element.attributes.key?(name.to_s.to_sym)
+            return
+          end
+
+          # Ox stores attributes with symbol keys, so try both string and symbol
+          value = element.attributes[name.to_s] || element.attributes[name.to_s.to_sym]
 
           ::Moxml::Adapter::CustomizedOx::Attribute.new(
-            name.to_s, element.attributes[name], element
+            name.to_s, value, element
           )
         end
 
@@ -299,6 +348,24 @@ module Moxml
         end
 
         def add_child(element, child)
+          # Special handling for declarations on Ox documents
+          if element.is_a?(::Ox::Document) && child.is_a?(::Ox::Instruct) && child.target == "xml"
+            # Transfer declaration attributes to document
+            element.attributes ||= {}
+            if child.attributes["version"]
+              element.attributes[:version] =
+                child.attributes["version"]
+            end
+            if child.attributes["encoding"]
+              element.attributes[:encoding] =
+                child.attributes["encoding"]
+            end
+            if child.attributes["standalone"]
+              element.attributes[:standalone] =
+                child.attributes["standalone"]
+            end
+          end
+
           child.parent = element if child.respond_to?(:parent)
           element.nodes ||= []
           element.nodes << child
@@ -331,11 +398,22 @@ module Moxml
 
           return unless parent(node)
 
-          parent(node).nodes.delete(node)
+          # Special handling for declarations on Ox documents
+          if parent(node).is_a?(::Ox::Document) && node.is_a?(::Ox::Instruct) && node.target == "xml"
+            # Clear declaration attributes from document
+            doc = parent(node)
+            doc.attributes&.delete(:version)
+            doc.attributes&.delete(:encoding)
+            doc.attributes&.delete(:standalone)
+          end
+
+          parent(node).nodes.delete(unpatch_node(node))
         end
 
         def replace(node, new_node)
-          return node.replace(new_node) if node.is_a?(String) && new_node.is_a?(String)
+          if node.is_a?(String) && new_node.is_a?(String)
+            return node.replace(new_node)
+          end
           # 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
@@ -357,10 +435,14 @@ module Moxml
         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
           else
+            return "" unless node.respond_to?(:nodes)
+
             node.nodes.map do |n|
               text_content(n)
             end.join
@@ -428,9 +510,38 @@ module Moxml
           end.values
         end
 
-        def xpath(node, expression, _namespaces = {})
-          # locate has a different syntax
-          node.locate(expression)
+        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
+          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}",
+            expression: expression,
+            adapter: "Ox",
+            node: node,
+          )
         end
 
         def at_xpath(node, expression, namespaces = {})
@@ -440,9 +551,24 @@ module Moxml
         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
+            # 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]
+              standalone = node[:standalone]
+
+              decl = create_native_declaration(version, encoding, standalone)
+              output = ::Ox.dump(::Ox::Document.new << decl).strip
+            end
           end
 
           ox_options = {
@@ -450,13 +576,76 @@ module Moxml
             # with_xml: true,
             with_instructions: true,
             encoding: options[:encoding],
-            no_empty: options[:expand_empty]
+            no_empty: options[:expand_empty],
           }
           output + ::Ox.dump(node, ox_options)
         end
 
         private
 
+        # 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.respond_to?(:nodes)
+
+            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
 
@@ -467,5 +656,110 @@ module Moxml
         end
       end
     end
+
+    # Bridge between Ox SAX and Moxml SAX
+    #
+    # Translates Ox::Sax events to Moxml::SAX::Handler events.
+    # Ox has a unique SAX pattern where attributes are delivered AFTER start_element.
+    #
+    # @private
+    class OxSAXBridge
+      def initialize(handler)
+        @handler = handler
+        @pending_attrs = {}
+        @pending_element_name = nil
+        @element_started = false
+        @document_started = false
+      end
+
+      # Ox delivers attributes AFTER start_element
+      def attr(name, value)
+        @pending_attrs[name] = value
+      end
+
+      # Called when element starts (but attributes come AFTER this)
+      def start_element(name)
+        # If we had a previous element waiting, we need to finalize it first
+        if @pending_element_name
+          finalize_pending_element
+        end
+
+        # Store this element name (convert symbol to string)
+        @pending_element_name = name.to_s
+        @element_started = true
+
+        # Call on_start_document if this is the first element
+        unless @document_started
+          @handler.on_start_document
+          @document_started = true
+        end
+      end
+
+      def end_element(name)
+        # Finalize any pending element before ending
+        if @pending_element_name
+          finalize_pending_element
+        end
+
+        # Convert symbol to string
+        @handler.on_end_element(name.to_s)
+      end
+
+      # Ox only has text() - no separate CDATA, comment, or PI events
+      def text(string)
+        # Finalize any pending element before text
+        if @pending_element_name
+          finalize_pending_element
+        end
+
+        @handler.on_characters(string)
+      end
+
+      def error(message, line, column)
+        error = Moxml::ParseError.new(message, line: line, column: column)
+        @handler.on_error(error)
+      end
+
+      # Called at end of parsing (not automatically by Ox)
+      def end_document
+        # Finalize any pending element
+        if @pending_element_name
+          finalize_pending_element
+        end
+
+        @handler.on_end_document if @document_started
+      end
+
+      private
+
+      def finalize_pending_element
+        # Separate namespace declarations from regular attributes
+        attr_hash = {}
+        namespaces_hash = {}
+
+        @pending_attrs.each do |attr_name, attr_value|
+          if attr_name.to_s.start_with?("xmlns")
+            # Namespace declaration
+            prefix = if attr_name.to_s == "xmlns"
+                       nil
+                     else
+                       attr_name.to_s.sub(
+                         "xmlns:", ""
+                       )
+                     end
+            namespaces_hash[prefix] = attr_value
+          else
+            attr_hash[attr_name.to_s] = attr_value
+          end
+        end
+
+        @handler.on_start_element(@pending_element_name, attr_hash,
+                                  namespaces_hash)
+
+        # Clear for next element
+        @pending_attrs = {}
+        @pending_element_name = nil
+      end
+    end
   end
 end