moxml 0.1.7 → 0.1.8

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
 
@@ -331,11 +380,13 @@ module Moxml
 
           return unless parent(node)
 
-          parent(node).nodes.delete(node)
+          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 +408,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 +483,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 = {})
@@ -441,7 +525,11 @@ module Moxml
           output = ""
           if node.is_a?(::Ox::Document)
             # add declaration
-            decl = create_native_declaration(node[:version], node[:encoding], node[:standalone])
+            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
 
@@ -450,13 +538,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 +618,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

data/lib/moxml/adapter/rexml.rb

@@ -14,13 +14,41 @@ module Moxml
           native_doc = begin
             ::REXML::Document.new(xml)
           rescue ::REXML::ParseException => e
-            raise Moxml::ParseError.new(e.message, line: e.line) if options[:strict]
-
+            if options[:strict]
+              raise Moxml::ParseError.new(
+                e.message,
+                line: e.line,
+                source: xml.is_a?(String) ? xml[0..100] : nil,
+              )
+            end
             create_document
           end
           DocumentBuilder.new(Context.new(:rexml)).build(native_doc)
         end
 
+        # SAX parsing implementation for REXML
+        #
+        # @param xml [String, IO] XML to parse
+        # @param handler [Moxml::SAX::Handler] Moxml SAX handler
+        # @return [void]
+        def sax_parse(xml, handler)
+          require "rexml/parsers/sax2parser"
+          require "rexml/source"
+          require "stringio"
+
+          bridge = REXMLSAX2Bridge.new(handler)
+
+          xml_string = xml.respond_to?(:read) ? xml.read : xml.to_s
+          source = ::REXML::IOSource.new(StringIO.new(xml_string))
+
+          parser = ::REXML::Parsers::SAX2Parser.new(source)
+          parser.listen(bridge)
+          parser.parse
+        rescue ::REXML::ParseException => e
+          error = Moxml::ParseError.new(e.message, line: e.line)
+          handler.on_error(error)
+        end
+
         def create_document(_native_doc = nil)
           ::REXML::Document.new
         end
@@ -55,10 +83,10 @@ module Moxml
 
           parts = [name]
           if external_id
-            parts.concat(["PUBLIC", %("#{external_id}")])
+            parts.push("PUBLIC", %("#{external_id}"))
             parts << %("#{system_id}") if system_id
           elsif system_id
-            parts.concat(["SYSTEM", %("#{system_id}")])
+            parts.push("SYSTEM", %("#{system_id}"))
           end
 
           ::REXML::DocType.new(parts.join(" "))
@@ -189,7 +217,7 @@ module Moxml
 
           # Only return non-namespace attributes
           element.attributes.values
-                 .reject { |attr| attr.prefix.to_s.start_with?("xmlns") }
+            .reject { |attr| attr.prefix.to_s.start_with?("xmlns") }
         end
 
         def attribute_element(attribute)
@@ -197,8 +225,8 @@ module Moxml
         end
 
         def set_attribute(element, name, value)
-          element.attributes[name&.to_s] = value
-          ::REXML::Attribute.new(name&.to_s, value.to_s, element)
+          element.attributes[name&.to_s] = value&.to_s
+          element.attributes.get_attribute(name&.to_s)
         end
 
         def set_attribute_name(attribute, name)
@@ -327,8 +355,8 @@ module Moxml
         def inner_text(node)
           # Get direct text children only, filter duplicates
           text_children = node.children
-                              .select { _1.is_a?(::REXML::Text) }
-                              .uniq(&:object_id)
+            .select { _1.is_a?(::REXML::Text) }
+            .uniq(&:object_id)
           text_children.map(&:value).join
         end
 
@@ -353,7 +381,10 @@ 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
-          element.add_namespace(prefix, ns.value) if element.respond_to?(:add_namespace)
+          if element.respond_to?(:add_namespace)
+            element.add_namespace(prefix,
+                                  ns.value)
+          end
           element.name = "#{prefix}:#{element.name}"
           owner = element.is_a?(::REXML::Attribute) ? element.element : element
           ::REXML::Attribute.new(prefix, ns.value, owner)
@@ -405,7 +436,12 @@ module Moxml
         def xpath(node, expression, _namespaces = {})
           node.get_elements(expression).to_a
         rescue ::REXML::ParseException => e
-          raise Moxml::XPathError, e.message
+          raise Moxml::XPathError.new(
+            e.message,
+            expression: expression,
+            adapter: "REXML",
+            node: node,
+          )
         end
 
         def at_xpath(node, expression, namespaces = {})
@@ -414,11 +450,12 @@ module Moxml
         end
 
         def serialize(node, options = {})
-          output = String.new
+          output = +""
 
           if node.is_a?(::REXML::Document)
             # Always include XML declaration
-            decl = node.xml_decl || ::REXML::XMLDecl.new("1.0", options[:encoding] || "UTF-8")
+            decl = node.xml_decl || ::REXML::XMLDecl.new("1.0",
+                                                         options[:encoding] || "UTF-8")
             decl.encoding = options[:encoding] if options[:encoding]
             output << "<?xml"
             output << %( version="#{decl.version}") if decl.version
@@ -427,20 +464,22 @@ module Moxml
             output << "?>"
             # output << "\n"
 
-            if node.doctype
-              node.doctype.write(output)
-              # output << "\n"
-            end
+            # output << "\n"
+            node.doctype&.write(output)
 
             # Write processing instructions
             node.children.each do |child|
-              next unless [::REXML::Instruction, ::REXML::CData, ::REXML::Comment, ::REXML::Text].include?(child.class)
+              next unless [::REXML::Instruction, ::REXML::CData,
+                           ::REXML::Comment, ::REXML::Text].include?(child.class)
 
               write_with_formatter(child, output, options[:indent] || 2)
               # output << "\n"
             end
 
-            write_with_formatter(node.root, output, options[:indent] || 2) if node.root
+            if node.root
+              write_with_formatter(node.root, output,
+                                   options[:indent] || 2)
+            end
           else
             write_with_formatter(node, output, options[:indent] || 2)
           end
@@ -452,11 +491,79 @@ module Moxml
 
         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,
           )
           formatter.write(node, output)
         end
       end
     end
+
+    # Bridge between REXML SAX2 and Moxml SAX
+    #
+    # Translates REXML::SAX2Parser events to Moxml::SAX::Handler events
+    #
+    # @private
+    class REXMLSAX2Bridge
+      def initialize(handler)
+        @handler = handler
+      end
+
+      # REXML splits element name into uri/localname/qname
+      def start_element(_uri, _localname, qname, attributes)
+        # Convert REXML attributes to hash
+        attr_hash = {}
+        ns_hash = {}
+
+        attributes.each do |name, value|
+          if name.to_s.start_with?("xmlns")
+            # Namespace declaration
+            prefix = name.to_s == "xmlns" ? nil : name.to_s.sub("xmlns:", "")
+            ns_hash[prefix] = value
+          else
+            attr_hash[name.to_s] = value
+          end
+        end
+
+        # Use qname (qualified name) for element name
+        @handler.on_start_element(qname, attr_hash, ns_hash)
+      end
+
+      def end_element(_uri, _localname, qname)
+        @handler.on_end_element(qname)
+      end
+
+      def characters(text)
+        @handler.on_characters(text)
+      end
+
+      def cdata(content)
+        @handler.on_cdata(content)
+      end
+
+      def comment(text)
+        @handler.on_comment(text)
+      end
+
+      def processing_instruction(target, data)
+        @handler.on_processing_instruction(target, data || "")
+      end
+
+      def start_document
+        @handler.on_start_document
+      end
+
+      def end_document
+        @handler.on_end_document
+      end
+
+      # REXML calls these but we don't need to handle them
+      def xmldecl(version, encoding, standalone)
+        # XML declaration - we don't need to do anything
+      end
+
+      def progress(position)
+        # Progress callback - we don't need to do anything
+      end
+    end
   end
 end