serialbench 0.1.1 → 0.1.2

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Serialbench
-  module Parsers
-    class BaseParser
-      attr_reader :name, :version
-
-      def initialize
-        @name = self.class.name.split('::').last.gsub('Parser', '').downcase
-        @version = detect_version
-      end
-
-      # Parse XML string into document object
-      def parse_dom(xml_string)
-        raise NotImplementedError, 'Subclasses must implement parse_dom'
-      end
-
-      # Parse XML with SAX-style streaming
-      def parse_sax(xml_string, handler = nil)
-        raise NotImplementedError, 'Subclasses must implement parse_sax'
-      end
-
-      # Generate XML string from document object
-      def generate_xml(document, options = {})
-        raise NotImplementedError, 'Subclasses must implement generate_xml'
-      end
-
-      # Check if library is available
-      def available?
-        require library_require_name
-        true
-      rescue LoadError
-        false
-      end
-
-      # Get library features
-      def features
-        {
-          xpath: supports_xpath?,
-          namespaces: supports_namespaces?,
-          validation: supports_validation?,
-          streaming: supports_streaming?
-        }
-      end
-
-      def supports_streaming?
-        false
-      end
-
-      protected
-
-      def detect_version
-        'unknown'
-      end
-
-      def supports_xpath?
-        false
-      end
-
-      def supports_namespaces?
-        true
-      end
-
-      def supports_validation?
-        false
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-# 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/nokogiri_parser.rb

@@ -1,111 +0,0 @@
-# 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/oga_parser.rb

@@ -1,85 +0,0 @@
-# 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/ox_parser.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_parser'
-
-module Serialbench
-  module Parsers
-    class OxParser < BaseParser
-      def parse_dom(xml_string)
-        require 'ox'
-        Ox.parse(xml_string)
-      end
-
-      def parse_sax(xml_string, handler = nil)
-        require 'ox'
-        require 'stringio'
-        handler ||= OxSaxHandler.new
-        Ox.sax_parse(handler, StringIO.new(xml_string))
-        handler
-      end
-
-      def generate_xml(document, options = {})
-        require 'ox'
-        indent = options.fetch(:indent, 0)
-        Ox.dump(document, indent: indent)
-      end
-
-      def supports_streaming?
-        true
-      end
-
-      # SAX handler for Ox
-      class OxSaxHandler < (defined?(::Ox) ? ::Ox::Sax : Object)
-        attr_reader :elements_processed, :text_nodes_processed
-
-        def initialize
-          @elements_processed = 0
-          @text_nodes_processed = 0
-        end
-
-        def start_element(name)
-          @elements_processed += 1
-        end
-
-        def end_element(name)
-          # Process end element
-        end
-
-        def text(value)
-          @text_nodes_processed += 1 unless value.strip.empty?
-        end
-
-        def attr(name, value)
-          # Process attribute
-        end
-      end
-
-      protected
-
-      def library_require_name
-        'ox'
-      end
-    end
-  end
-end

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

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_parser'
-
-module Serialbench
-  module Parsers
-    class RexmlParser < BaseParser
-      def parse_dom(xml_string)
-        require 'rexml/document'
-        REXML::Document.new(xml_string)
-      end
-
-      def parse_sax(xml_string, handler = nil)
-        require 'rexml/parsers/sax2parser'
-        handler ||= DefaultSaxHandler.new
-        parser = REXML::Parsers::SAX2Parser.new(xml_string)
-        parser.listen(handler)
-        parser.parse
-        handler
-      rescue LoadError
-        # Fallback if SAX2 is not available
-        require 'rexml/document'
-        doc = REXML::Document.new(xml_string)
-        handler ||= DefaultSaxHandler.new
-        # Simulate SAX events by walking the document
-        doc.root.each_recursive do |element|
-          if element.is_a?(REXML::Element)
-            handler.start_element(nil, element.name, element.name, element.attributes)
-            handler.end_element(nil, element.name, element.name)
-          elsif element.is_a?(REXML::Text)
-            handler.characters(element.to_s)
-          end
-        end
-        handler
-      end
-
-      def generate_xml(document, options = {})
-        require 'rexml/document'
-        indent = options.fetch(:indent, 0)
-        output = String.new
-        if indent > 0
-          document.write(output, indent)
-        else
-          document.write(output)
-        end
-        output
-      end
-
-      def supports_streaming?
-        true
-      end
-
-      protected
-
-      def library_require_name
-        'rexml/document'
-      end
-
-      def detect_version
-        require 'rexml/rexml'
-        REXML::VERSION
-      rescue LoadError, NameError
-        'built-in'
-      end
-
-      def supports_xpath?
-        true
-      end
-
-      def supports_namespaces?
-        true
-      end
-
-      def supports_validation?
-        false
-      end
-    end
-
-    # Default SAX handler for REXML - only define if REXML SAX is available
-    begin
-      require 'rexml/sax2listener'
-
-      class DefaultSaxHandler
-        include ::REXML::SAX2Listener
-
-        attr_reader :elements_processed, :text_nodes_processed
-
-        def initialize
-          @elements_processed = 0
-          @text_nodes_processed = 0
-        end
-
-        def start_element(uri, localname, qname, attributes)
-          @elements_processed += 1
-        end
-
-        def characters(text)
-          @text_nodes_processed += 1 unless text.strip.empty?
-        end
-
-        def end_element(uri, localname, qname)
-          # Element processing complete
-        end
-      end
-    rescue LoadError
-      # SAX2Listener not available, define a simple handler
-      class DefaultSaxHandler
-        attr_reader :elements_processed, :text_nodes_processed
-
-        def initialize
-          @elements_processed = 0
-          @text_nodes_processed = 0
-        end
-
-        def start_element(uri, localname, qname, attributes)
-          @elements_processed += 1
-        end
-
-        def characters(text)
-          @text_nodes_processed += 1 unless text.strip.empty?
-        end
-
-        def end_element(uri, localname, qname)
-          # Element processing complete
-        end
-      end
-    end
-  end
-end