serialbench 0.1.0

data/lib/serialbench/serializers/xml/libxml_parser.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'base_parser'
+
+module Serialbench
+  module Parsers
+    class LibxmlParser < BaseParser
+      def parse_dom(xml_string)
+        require 'libxml'
+        LibXML::XML::Document.string(xml_string)
+      end
+
+      def parse_sax(xml_string, handler = nil)
+        require 'libxml'
+        handler ||= LibxmlSaxHandler.new
+        parser = LibXML::XML::SaxParser.string(xml_string)
+        parser.callbacks = handler
+        parser.parse
+        handler
+      end
+
+      def generate_xml(document, options = {})
+        require 'libxml'
+        document.to_s
+      end
+
+      def supports_streaming?
+        true
+      end
+
+      # SAX handler for LibXML
+      class LibxmlSaxHandler
+        attr_reader :elements_processed, :text_nodes_processed
+
+        def initialize
+          @elements_processed = 0
+          @text_nodes_processed = 0
+          # Include LibXML callbacks if available
+          return unless defined?(::LibXML)
+
+          return if self.class.ancestors.include?(::LibXML::XML::SaxParser::Callbacks)
+
+          self.class.send(:include,
+                          ::LibXML::XML::SaxParser::Callbacks)
+        end
+
+        def on_start_document
+          # Document processing started
+        end
+
+        def on_end_document
+          # Document processing complete
+        end
+
+        def on_start_element(element, attributes)
+          @elements_processed += 1
+        end
+
+        def on_characters(chars)
+          @text_nodes_processed += 1 unless chars.strip.empty?
+        end
+
+        def on_end_element(element)
+          # Element processing complete
+        end
+
+        def on_error(msg)
+          # Handle parsing errors
+        end
+      end
+
+      protected
+
+      def library_require_name
+        'libxml'
+      end
+
+      def detect_version
+        require 'libxml'
+        LibXML::XML::VERSION
+      rescue LoadError
+        'not available'
+      end
+
+      def supports_xpath?
+        true
+      end
+
+      def supports_namespaces?
+        true
+      end
+
+      def supports_validation?
+        true
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/xml/libxml_serializer.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'base_xml_serializer'
+
+module Serialbench
+  module Serializers
+    module Xml
+      class LibxmlSerializer < BaseXmlSerializer
+        def name
+          'libxml'
+        end
+
+        def parse(xml_string)
+          require 'libxml'
+          LibXML::XML::Parser.string(xml_string).parse
+        end
+
+        def generate(data)
+          require 'libxml'
+          # If data is already a LibXML document, convert to string
+          if data.respond_to?(:to_s) && data.class.name.include?('LibXML')
+            data.to_s(indent: true)
+          else
+            # Create a simple XML structure from hash-like data
+            doc = LibXML::XML::Document.new
+            doc.root = build_xml_from_data(data)
+            doc.to_s(indent: true)
+          end
+        end
+
+        def parse_streaming(xml_string, &block)
+          require 'libxml'
+
+          handler = StreamingHandler.new(&block)
+          parser = LibXML::XML::SaxParser.string(xml_string)
+          parser.callbacks = handler
+          parser.parse
+          handler.elements_processed
+        end
+
+        def supports_streaming?
+          true
+        end
+
+        def version
+          return 'unknown' unless available?
+
+          require 'libxml'
+          LibXML::XML::VERSION
+        end
+
+        protected
+
+        def library_require_name
+          'libxml'
+        end
+
+        private
+
+        def build_xml_from_data(data, name = 'root')
+          require 'libxml'
+
+          case data
+          when Hash
+            element = LibXML::XML::Node.new(name.to_s)
+            data.each do |key, value|
+              child = build_xml_from_data(value, key.to_s)
+              element << child
+            end
+            element
+          when Array
+            element = LibXML::XML::Node.new(name.to_s)
+            data.each_with_index do |item, index|
+              child = build_xml_from_data(item, "item_#{index}")
+              element << child
+            end
+            element
+          else
+            element = LibXML::XML::Node.new(name.to_s)
+            element.content = data.to_s
+            element
+          end
+        end
+
+        # SAX handler for streaming
+        class StreamingHandler
+          include LibXML::XML::SaxParser::Callbacks if defined?(LibXML::XML::SaxParser::Callbacks)
+
+          attr_reader :elements_processed
+
+          def initialize(&block)
+            @block = block
+            @elements_processed = 0
+            @current_element = nil
+            @element_stack = []
+          end
+
+          def on_start_element(element, attributes)
+            @elements_processed += 1
+            attrs = Hash[attributes || []]
+            @current_element = { name: element, attributes: attrs, children: [], text: '' }
+            @element_stack.push(@current_element)
+          end
+
+          def on_end_element(element)
+            element_data = @element_stack.pop
+            if @element_stack.empty?
+              @block&.call(element_data) if @block
+            else
+              @element_stack.last[:children] << element_data
+            end
+          end
+
+          def on_characters(chars)
+            return if chars.strip.empty?
+
+            @element_stack.last[:text] += chars if @element_stack.any?
+          end
+
+          def on_cdata_block(cdata)
+            @element_stack.last[:text] += cdata if @element_stack.any?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/xml/nokogiri_parser.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative 'base_parser'
+
+module Serialbench
+  module Parsers
+    class NokogiriParser < BaseParser
+      def parse_dom(xml_string)
+        require 'nokogiri'
+        Nokogiri::XML(xml_string)
+      end
+
+      def parse_sax(xml_string, handler = nil)
+        require 'nokogiri'
+        handler ||= NokogiriSaxHandler.new
+        parser = Nokogiri::XML::SAX::Parser.new(handler)
+        parser.parse(xml_string)
+        handler
+      end
+
+      def generate_xml(document, options = {})
+        require 'nokogiri'
+        indent = options.fetch(:indent, 0)
+        if indent > 0
+          document.to_xml(indent: indent)
+        else
+          document.to_xml
+        end
+      end
+
+      def supports_streaming?
+        true
+      end
+
+      # SAX handler for Nokogiri
+      class NokogiriSaxHandler < (defined?(::Nokogiri) ? ::Nokogiri::XML::SAX::Document : Object)
+        attr_reader :elements_processed, :text_nodes_processed
+
+        def initialize
+          @elements_processed = 0
+          @text_nodes_processed = 0
+        end
+
+        def start_document
+          # Document processing started
+        end
+
+        def end_document
+          # Document processing complete
+        end
+
+        def start_element(name, attrs = [])
+          @elements_processed += 1
+        end
+
+        def start_element_namespace(name, attrs = [], prefix = nil, uri = nil, ns = [])
+          @elements_processed += 1
+        end
+
+        def characters(string)
+          @text_nodes_processed += 1 unless string.strip.empty?
+        end
+
+        def end_element(name)
+          # Element processing complete
+        end
+
+        def end_element_namespace(name, prefix = nil, uri = nil)
+          # Element processing complete
+        end
+
+        def error(message)
+          # Handle parsing errors
+        end
+
+        def warning(message)
+          # Handle parsing warnings
+        end
+
+        def xmldecl(version, encoding, standalone)
+          # Handle XML declaration
+        end
+      end
+
+      protected
+
+      def library_require_name
+        'nokogiri'
+      end
+
+      def detect_version
+        require 'nokogiri'
+        Nokogiri::VERSION
+      rescue LoadError
+        'not available'
+      end
+
+      def supports_xpath?
+        true
+      end
+
+      def supports_namespaces?
+        true
+      end
+
+      def supports_validation?
+        true
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/xml/nokogiri_serializer.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative 'base_xml_serializer'
+
+module Serialbench
+  module Serializers
+    module Xml
+      class NokogiriSerializer < BaseXmlSerializer
+        def name
+          'nokogiri'
+        end
+
+        def parse(xml_string)
+          require 'nokogiri'
+          Nokogiri::XML(xml_string)
+        end
+
+        def generate(data)
+          require 'nokogiri'
+          # If data is already a Nokogiri document, convert to string
+          if data.respond_to?(:to_xml)
+            data.to_xml(indent: 2)
+          else
+            # Create a simple XML structure from hash-like data
+            builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+              build_xml_from_data(xml, data)
+            end
+            builder.to_xml
+          end
+        end
+
+        def parse_streaming(xml_string, &block)
+          require 'nokogiri'
+
+          handler = StreamingHandler.new(&block)
+          parser = Nokogiri::XML::SAX::Parser.new(handler)
+          parser.parse(xml_string)
+          handler.elements_processed
+        end
+
+        def supports_streaming?
+          true
+        end
+
+        def version
+          return 'unknown' unless available?
+
+          require 'nokogiri'
+          Nokogiri::VERSION
+        end
+
+        protected
+
+        def library_require_name
+          'nokogiri'
+        end
+
+        private
+
+        def build_xml_from_data(xml, data, root_name = 'root')
+          case data
+          when Hash
+            xml.send(root_name) do
+              data.each do |key, value|
+                build_xml_from_data(xml, value, key)
+              end
+            end
+          when Array
+            data.each_with_index do |item, index|
+              build_xml_from_data(xml, item, "item_#{index}")
+            end
+          else
+            xml.send(root_name, data.to_s)
+          end
+        end
+
+        # SAX handler for streaming
+        class StreamingHandler
+          attr_reader :elements_processed
+
+          def initialize(&block)
+            require 'nokogiri'
+            @block = block
+            @elements_processed = 0
+            @current_element = nil
+            @element_stack = []
+          end
+
+          def start_element(name, attributes = [])
+            @elements_processed += 1
+            attrs = Hash[attributes]
+            @current_element = { name: name, attributes: attrs, children: [], text: '' }
+            @element_stack.push(@current_element)
+          end
+
+          def end_element(name)
+            element = @element_stack.pop
+            if @element_stack.empty?
+              @block&.call(element) if @block
+            else
+              @element_stack.last[:children] << element
+            end
+          end
+
+          def characters(string)
+            return if string.strip.empty?
+
+            @element_stack.last[:text] += string if @element_stack.any?
+          end
+
+          def cdata_block(string)
+            @element_stack.last[:text] += string if @element_stack.any?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/xml/oga_parser.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative 'base_parser'
+
+module Serialbench
+  module Parsers
+    class OgaParser < BaseParser
+      def parse_dom(xml_string)
+        require 'oga'
+        Oga.parse_xml(xml_string)
+      end
+
+      def parse_sax(xml_string, handler = nil)
+        require 'oga'
+        handler ||= DefaultSaxHandler.new
+        Oga.sax_parse_xml(xml_string, handler)
+        handler
+      end
+
+      def generate_xml(document, options = {})
+        require 'oga'
+        document.to_xml
+      end
+
+      def supports_streaming?
+        true
+      end
+
+      protected
+
+      def library_require_name
+        'oga'
+      end
+
+      def detect_version
+        require 'oga'
+        Oga::VERSION
+      rescue LoadError
+        'not available'
+      end
+
+      def supports_xpath?
+        true
+      end
+
+      def supports_namespaces?
+        true
+      end
+
+      def supports_validation?
+        false
+      end
+
+      # Default SAX handler for Oga
+      class DefaultSaxHandler
+        attr_reader :elements_processed, :text_nodes_processed
+
+        def initialize
+          @elements_processed = 0
+          @text_nodes_processed = 0
+        end
+
+        def on_element(namespace, name, attributes = {})
+          @elements_processed += 1
+        end
+
+        def on_text(text)
+          @text_nodes_processed += 1 unless text.strip.empty?
+        end
+
+        def on_cdata(text)
+          @text_nodes_processed += 1 unless text.strip.empty?
+        end
+
+        def on_comment(text)
+          # Handle comments
+        end
+
+        def on_processing_instruction(name, text)
+          # Handle processing instructions
+        end
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/xml/oga_serializer.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative 'base_xml_serializer'
+
+module Serialbench
+  module Serializers
+    module Xml
+      class OgaSerializer < BaseXmlSerializer
+        def name
+          'oga'
+        end
+
+        def parse(xml_string)
+          require 'oga'
+          Oga.parse_xml(xml_string)
+        end
+
+        def generate(data)
+          require 'oga'
+          # If data is already an Oga document, convert to string
+          if data.respond_to?(:to_xml)
+            data.to_xml
+          else
+            # Create a simple XML structure from hash-like data
+            document = Oga::XML::Document.new
+            root = build_xml_from_data(data)
+            document.children << root
+            document.to_xml
+          end
+        end
+
+        def parse_streaming(xml_string, &block)
+          require 'oga'
+
+          handler = StreamingHandler.new(&block)
+          parser = Oga::XML::SaxParser.new(handler, xml_string)
+          parser.parse
+          handler.elements_processed
+        end
+
+        def supports_streaming?
+          true
+        end
+
+        def version
+          return 'unknown' unless available?
+
+          require 'oga'
+          Oga::VERSION
+        end
+
+        protected
+
+        def library_require_name
+          'oga'
+        end
+
+        private
+
+        def build_xml_from_data(data, name = 'root')
+          require 'oga'
+
+          case data
+          when Hash
+            element = Oga::XML::Element.new(name: name)
+            data.each do |key, value|
+              child = build_xml_from_data(value, key.to_s)
+              element.children << child
+            end
+            element
+          when Array
+            element = Oga::XML::Element.new(name: name)
+            data.each_with_index do |item, index|
+              child = build_xml_from_data(item, "item_#{index}")
+              element.children << child
+            end
+            element
+          else
+            element = Oga::XML::Element.new(name: name)
+            text_node = Oga::XML::Text.new(text: data.to_s)
+            element.children << text_node
+            element
+          end
+        end
+
+        # SAX handler for streaming
+        class StreamingHandler
+          attr_reader :elements_processed
+
+          def initialize(&block)
+            @block = block
+            @elements_processed = 0
+            @current_element = nil
+            @element_stack = []
+          end
+
+          def on_element(namespace, name, attributes = {})
+            @elements_processed += 1
+            @current_element = { name: name, namespace: namespace, attributes: attributes, children: [], text: '' }
+            @element_stack.push(@current_element)
+          end
+
+          def on_text(text)
+            return if text.strip.empty?
+
+            @element_stack.last[:text] += text if @element_stack.any?
+          end
+
+          def on_cdata(text)
+            @element_stack.last[:text] += text if @element_stack.any?
+          end
+
+          def after_element(namespace, name)
+            element = @element_stack.pop
+            if @element_stack.empty?
+              @block&.call(element) if @block
+            else
+              @element_stack.last[:children] << element
+            end
+          end
+        end
+      end
+    end
+  end
+end