moxml 0.1.6 → 0.1.8

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
 
@@ -274,27 +299,43 @@ 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
+          if options[:no_declaration]
+            save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+          end
 
           node.to_xml(
             indent: options[:indent],
             encoding: options[:encoding],
-            save_with: save_options
+            save_with: save_options,
           )
         end
 
@@ -316,6 +357,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

@@ -18,12 +18,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 +71,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 +83,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 +109,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 +161,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 +213,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
@@ -313,15 +349,26 @@ 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 = {})
@@ -330,5 +377,69 @@ module Moxml
         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