moxml 0.1.7 → 0.1.9

data/lib/moxml/adapter/nokogiri.rb

@@ -25,12 +25,37 @@ module Moxml
               end
             end
           rescue ::Nokogiri::XML::SyntaxError => e
-            raise Moxml::ParseError.new(e.message, line: e.line, column: e.column)
+            raise Moxml::ParseError.new(e.message, line: e.line,
+                                                   column: e.column)
           end
 
           DocumentBuilder.new(Context.new(:nokogiri)).build(native_doc)
         end
 
+        # SAX parsing implementation for Nokogiri
+        #
+        # @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 Nokogiri SAX to Moxml SAX
+          bridge = NokogiriSAXBridge.new(handler)
+
+          # Create Nokogiri SAX parser
+          parser = ::Nokogiri::XML::SAX::Parser.new(bridge)
+
+          # Parse
+          if xml.respond_to?(:read)
+            parser.parse(xml)
+          else
+            parser.parse(xml.to_s)
+          end
+        rescue ::Nokogiri::XML::SyntaxError => e
+          error = Moxml::ParseError.new(e.message, line: e.line,
+                                                   column: e.column)
+          handler.on_error(error)
+        end
+
         def create_document(_native_doc = nil)
           ::Nokogiri::XML::Document.new
         end
@@ -39,7 +64,7 @@ module Moxml
           # document fragments are weird and should be used with caution:
           # https://github.com/sparklemotion/nokogiri/issues/572
           ::Nokogiri::XML::DocumentFragment.new(
-            ::Nokogiri::XML::Document.new
+            ::Nokogiri::XML::Document.new,
           )
         end
 
@@ -75,7 +100,7 @@ module Moxml
           ::Nokogiri::XML::ProcessingInstruction.new(
             create_document,
             "xml",
-            build_declaration_attrs(version, encoding, standalone)
+            build_declaration_attrs(version, encoding, standalone),
           )
         end
 
@@ -196,6 +221,23 @@ module Moxml
         end
 
         def add_child(element, child)
+          # Special handling for declarations on Nokogiri documents
+          if element.is_a?(::Nokogiri::XML::Document) &&
+              child.is_a?(::Nokogiri::XML::ProcessingInstruction) &&
+              child.name == "xml"
+            # Set document's xml_decl property
+            version = declaration_attribute(child, "version") || "1.0"
+            encoding = declaration_attribute(child, "encoding")
+            standalone = declaration_attribute(child, "standalone")
+
+            # Nokogiri's xml_decl can only be set via instance variable
+            element.instance_variable_set(:@xml_decl, {
+              version: version,
+              encoding: encoding,
+              standalone: standalone,
+            }.compact)
+          end
+
           if node_type(child) == :doctype
             # avoid exceptions: cannot reparent Nokogiri::XML::DTD there
             element.create_internal_subset(
@@ -215,6 +257,14 @@ module Moxml
         end
 
         def remove(node)
+          # Special handling for declarations on Nokogiri documents
+          if node.is_a?(::Nokogiri::XML::ProcessingInstruction) &&
+              node.name == "xml" &&
+              node.parent.is_a?(::Nokogiri::XML::Document)
+            # Clear document's xml_decl when removing declaration
+            node.parent.instance_variable_set(:@xml_decl, nil)
+          end
+
           node.remove
         end
 
@@ -274,27 +324,53 @@ module Moxml
         def xpath(node, expression, namespaces = nil)
           node.xpath(expression, namespaces).to_a
         rescue ::Nokogiri::XML::XPath::SyntaxError => e
-          raise Moxml::XPathError, e.message
+          raise Moxml::XPathError.new(
+            e.message,
+            expression: expression,
+            adapter: "Nokogiri",
+            node: node,
+          )
         end
 
         def at_xpath(node, expression, namespaces = nil)
           node.at_xpath(expression, namespaces)
         rescue ::Nokogiri::XML::XPath::SyntaxError => e
-          raise Moxml::XPathError, e.message
+          raise Moxml::XPathError.new(
+            e.message,
+            expression: expression,
+            adapter: "Nokogiri",
+            node: node,
+          )
         end
 
         def serialize(node, options = {})
           save_options = ::Nokogiri::XML::Node::SaveOptions::AS_XML
 
           # Don't force expand empty elements if they're really empty
-          save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS if options[:expand_empty]
-          save_options |= ::Nokogiri::XML::Node::SaveOptions::FORMAT if options[:indent].to_i.positive?
-          save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION if options[:no_declaration]
+          if options[:expand_empty]
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS
+          end
+          if options[:indent].to_i.positive?
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::FORMAT
+          end
+
+          # Handle declaration option
+          # Priority:
+          # 1. Explicit no_declaration option
+          # 2. Check Nokogiri's internal @xml_decl (when remove is called, this becomes nil)
+          if options.key?(:no_declaration)
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION if options[:no_declaration]
+          elsif node.respond_to?(:instance_variable_get) &&
+              node.instance_variable_defined?(:@xml_decl)
+            # Nokogiri's internal state - if nil, declaration was removed
+            xml_decl = node.instance_variable_get(:@xml_decl)
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION if xml_decl.nil?
+          end
 
           node.to_xml(
             indent: options[:indent],
             encoding: options[:encoding],
-            save_with: save_options
+            save_with: save_options,
           )
         end
 
@@ -316,6 +392,77 @@ module Moxml
           end
         end
       end
+
+      # Bridge between Nokogiri SAX and Moxml SAX
+      #
+      # Translates Nokogiri::XML::SAX::Document events to Moxml::SAX::Handler events
+      #
+      # @private
+      class NokogiriSAXBridge < ::Nokogiri::XML::SAX::Document
+        def initialize(handler)
+          super()
+          @handler = handler
+        end
+
+        # Map Nokogiri events to Moxml events
+
+        def start_document
+          @handler.on_start_document
+        end
+
+        def end_document
+          @handler.on_end_document
+        end
+
+        def start_element(name, attributes = [])
+          # Convert Nokogiri attributes array to hash
+          attr_hash = {}
+          namespaces_hash = {}
+
+          attributes.each do |attr|
+            attr_name = attr[0]
+            attr_value = attr[1]
+
+            if attr_name.start_with?("xmlns")
+              # Namespace declaration
+              prefix = attr_name == "xmlns" ? nil : attr_name.sub("xmlns:", "")
+              namespaces_hash[prefix] = attr_value
+            else
+              attr_hash[attr_name] = attr_value
+            end
+          end
+
+          @handler.on_start_element(name, attr_hash, namespaces_hash)
+        end
+
+        def end_element(name)
+          @handler.on_end_element(name)
+        end
+
+        def characters(string)
+          @handler.on_characters(string)
+        end
+
+        def cdata_block(string)
+          @handler.on_cdata(string)
+        end
+
+        def comment(string)
+          @handler.on_comment(string)
+        end
+
+        def processing_instruction(target, data)
+          @handler.on_processing_instruction(target, data || "")
+        end
+
+        def error(string)
+          @handler.on_error(Moxml::ParseError.new(string))
+        end
+
+        def warning(string)
+          @handler.on_warning(string)
+        end
+      end
     end
   end
 end

data/lib/moxml/adapter/oga.rb

@@ -10,7 +10,10 @@ module Moxml
     class Oga < Base
       class << self
         def set_root(doc, element)
-          doc.children.clear # Clear any existing children
+          # Clear existing root element if any - Oga's NodeSet needs special handling
+          # We need to manually remove elements since NodeSet doesn't support clear or delete_if
+          elements_to_remove = doc.children.select { |child| child.is_a?(::Oga::XML::Element) }
+          elements_to_remove.each { |elem| doc.children.delete(elem) }
           doc.children << element
         end
 
@@ -18,12 +21,37 @@ module Moxml
           native_doc = begin
             ::Oga.parse_xml(xml, strict: options[:strict])
           rescue LL::ParserError => 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(:oga)).build(native_doc)
         end
 
+        # SAX parsing implementation for Oga
+        #
+        # @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.respond_to?(:read) ? xml.read : xml.to_s
+
+          # 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
+        rescue StandardError => e
+          error = Moxml::ParseError.new(e.message)
+          handler.on_error(error)
+        end
+
         def create_document(_native_doc = nil)
           ::Oga::XML::Document.new
         end
@@ -46,7 +74,7 @@ module Moxml
 
         def create_native_doctype(name, external_id, system_id)
           ::Oga::XML::Doctype.new(
-            name: name, public_id: external_id, system_id: system_id, type: "PUBLIC"
+            name: name, public_id: external_id, system_id: system_id, type: "PUBLIC",
           )
         end
 
@@ -58,19 +86,23 @@ module Moxml
           attrs = {
             version: version,
             encoding: encoding,
-            standalone: standalone
+            standalone: standalone,
           }.compact
           ::Moxml::Adapter::CustomizedOga::XmlDeclaration.new(attrs)
         end
 
         def declaration_attribute(declaration, attr_name)
-          return unless ::Moxml::Declaration::ALLOWED_ATTRIBUTES.include?(attr_name.to_s)
+          unless ::Moxml::Declaration::ALLOWED_ATTRIBUTES.include?(attr_name.to_s)
+            return
+          end
 
           declaration.public_send(attr_name)
         end
 
         def set_declaration_attribute(declaration, attr_name, value)
-          return unless ::Moxml::Declaration::ALLOWED_ATTRIBUTES.include?(attr_name.to_s)
+          unless ::Moxml::Declaration::ALLOWED_ATTRIBUTES.include?(attr_name.to_s)
+            return
+          end
 
           declaration.public_send("#{attr_name}=", value)
         end
@@ -80,7 +112,8 @@ module Moxml
           return ns unless ns.nil?
 
           # Oga creates an attribute and registers a namespace
-          set_attribute(element, [::Oga::XML::Element::XMLNS_PREFIX, prefix].compact.join(":"), uri)
+          set_attribute(element,
+                        [::Oga::XML::Element::XMLNS_PREFIX, prefix].compact.join(":"), uri)
           element.register_namespace(prefix, uri)
           ::Oga::XML::Namespace.new(name: prefix, uri: uri)
         end
@@ -131,7 +164,10 @@ module Moxml
         def children(node)
           all_children = []
 
-          all_children += [node.xml_declaration, node.doctype].compact if node.is_a?(::Oga::XML::Document)
+          if node.is_a?(::Oga::XML::Document)
+            all_children += [node.xml_declaration,
+                             node.doctype].compact
+          end
 
           return all_children unless node.respond_to?(:children)
 
@@ -180,12 +216,15 @@ module Moxml
 
         def set_attribute(element, name, value)
           namespace_name = nil
-          namespace_name, name = name.to_s.split(":", 2) if name.to_s.include?(":")
+          if name.to_s.include?(":")
+            namespace_name, name = name.to_s.split(":",
+                                                   2)
+          end
 
           attr = ::Oga::XML::Attribute.new(
             name: name.to_s,
             namespace_name: namespace_name,
-            value: value.to_s
+            value: value.to_s,
           )
           element.add_attribute(attr)
         end
@@ -211,6 +250,13 @@ module Moxml
               child_or_text
             end
 
+          # Special handling for declarations on Oga documents
+          if element.is_a?(::Oga::XML::Document) &&
+              child.is_a?(::Oga::XML::XmlDeclaration)
+            # Set as document's xml_declaration
+            element.instance_variable_set(:@xml_declaration, child)
+          end
+
           element.children << child
         end
 
@@ -237,6 +283,13 @@ module Moxml
         end
 
         def remove(node)
+          # Special handling for declarations on Oga documents
+          if node.is_a?(::Oga::XML::XmlDeclaration) &&
+              node.parent.is_a?(::Oga::XML::Document)
+            # Clear document's xml_declaration when removing declaration
+            node.parent.instance_variable_set(:@xml_declaration, nil)
+          end
+
           node.remove
         end
 
@@ -313,22 +366,144 @@ module Moxml
         end
 
         def xpath(node, expression, namespaces = nil)
-          node.xpath(expression, {}, namespaces: namespaces&.transform_keys(&:to_s)).to_a
+          node.xpath(expression, {},
+                     namespaces: namespaces&.transform_keys(&:to_s)).to_a
         rescue ::LL::ParserError => e
-          raise Moxml::XPathError, e.message
+          raise Moxml::XPathError.new(
+            e.message,
+            expression: expression,
+            adapter: "Oga",
+            node: node,
+          )
         end
 
         def at_xpath(node, expression, namespaces = nil)
           node.at_xpath(expression, namespaces: namespaces)
         rescue ::Oga::XPath::Error => e
-          raise Moxml::XPathError, e.message
+          raise Moxml::XPathError.new(
+            e.message,
+            expression: expression,
+            adapter: "Oga",
+            node: node,
+          )
         end
 
-        def serialize(node, _options = {})
-          # Expand empty tags, encode attributes, etc
+        def serialize(node, options = {})
+          # Oga's XmlGenerator doesn't support options directly
+          # We need to handle declaration options ourselves for Document nodes
+          if node.is_a?(::Oga::XML::Document)
+            # Check if we should include declaration
+            # Priority: explicit option > existence of xml_declaration node
+            should_include_decl = if options.key?(:no_declaration)
+                                    !options[:no_declaration]
+                                  elsif options.key?(:declaration)
+                                    options[:declaration]
+                                  else
+                                    # Default: include if document has xml_declaration node
+                                    node.xml_declaration ? true : false
+                                  end
+
+            if should_include_decl && !node.xml_declaration
+              # Need to add declaration - create default one
+              output = +""
+              output << '<?xml version="1.0" encoding="UTF-8"?>'
+              output << "\n"
+
+              # Serialize doctype if present
+              output << node.doctype.to_xml << "\n" if node.doctype
+
+              # Serialize children
+              node.children.each do |child|
+                output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
+              end
+
+              return output
+            elsif !should_include_decl
+              # Skip xml_declaration
+              output = +""
+
+              # Serialize doctype if present
+              output << node.doctype.to_xml << "\n" if node.doctype
+
+              # Serialize root and other children
+              node.children.each do |child|
+                next if child.is_a?(::Oga::XML::XmlDeclaration)
+
+                output << ::Moxml::Adapter::CustomizedOga::XmlGenerator.new(child).to_xml
+              end
+
+              return output
+            end
+          end
+
+          # Default: use XmlGenerator
           ::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
+      def initialize(handler)
+        @handler = handler
+      end
+
+      # Oga: on_element(namespace, name, attributes)
+      # namespace may be nil
+      # attributes is an array of [name, value] pairs
+      def on_element(namespace, name, attributes)
+        # Build full qualified name if namespace present
+        element_name = namespace ? "#{namespace}:#{name}" : name
+
+        # Convert Oga attributes to hash
+        attr_hash = {}
+        ns_hash = {}
+
+        # Oga delivers attributes as array of [name, value] pairs
+        attributes.each do |attr_name, attr_value|
+          if attr_name.to_s.start_with?("xmlns")
+            prefix = if attr_name.to_s == "xmlns"
+                       nil
+                     else
+                       attr_name.to_s.sub(
+                         "xmlns:", ""
+                       )
+                     end
+            ns_hash[prefix] = attr_value
+          else
+            attr_hash[attr_name.to_s] = attr_value
+          end
+        end
+
+        @handler.on_start_element(element_name, attr_hash, ns_hash)
+      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_text(text)
+        @handler.on_characters(text)
+      end
+
+      def on_cdata(text)
+        @handler.on_cdata(text)
+      end
+
+      def on_comment(text)
+        @handler.on_comment(text)
+      end
+
+      def on_processing_instruction(name, text)
+        @handler.on_processing_instruction(name, text || "")
+      end
+    end
   end
 end