serialbench 0.1.0

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

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative 'base_xml_serializer'
+
+module Serialbench
+  module Serializers
+    module Xml
+      class OxSerializer < BaseXmlSerializer
+        def name
+          'ox'
+        end
+
+        def parse(xml_string)
+          require 'ox'
+          Ox.parse(xml_string)
+        end
+
+        def generate(data)
+          require 'ox'
+          Ox.dump(data, indent: 2)
+        end
+
+        def parse_streaming(xml_string, &block)
+          require 'ox'
+          require 'stringio'
+
+          handler = StreamingHandler.new(&block)
+          Ox.sax_parse(handler, StringIO.new(xml_string))
+          handler.elements_processed
+        end
+
+        def supports_streaming?
+          true
+        end
+
+        def version
+          return 'unknown' unless available?
+
+          require 'ox'
+          Ox::VERSION
+        end
+
+        protected
+
+        def library_require_name
+          'ox'
+        end
+
+        # SAX handler for streaming
+        class StreamingHandler < (defined?(::Ox) ? ::Ox::Sax : Object)
+          attr_reader :elements_processed
+
+          def initialize(&block)
+            @block = block
+            @elements_processed = 0
+            @current_element = nil
+            @element_stack = []
+          end
+
+          def start_element(name)
+            @elements_processed += 1
+            @current_element = { name: name, attributes: {}, 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 text(value)
+            return if value.strip.empty?
+
+            @element_stack.last[:text] += value if @element_stack.any?
+          end
+
+          def attr(name, value)
+            @element_stack.last[:attributes][name] = value if @element_stack.any?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# 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

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative 'base_xml_serializer'
+
+module Serialbench
+  module Serializers
+    module Xml
+      class RexmlSerializer < BaseXmlSerializer
+        def available?
+          require_library('rexml/document')
+        end
+
+        def name
+          'rexml'
+        end
+
+        def version
+          require 'rexml/rexml'
+          REXML::VERSION
+        rescue LoadError, NameError
+          'built-in'
+        end
+
+        def parse(xml_string)
+          require 'rexml/document'
+          REXML::Document.new(xml_string)
+        end
+
+        def generate(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 stream_parse(xml_string, &block)
+          require 'rexml/parsers/sax2parser'
+          handler = SaxHandler.new(&block)
+          parser = REXML::Parsers::SAX2Parser.new(xml_string)
+          parser.listen(handler)
+          parser.parse
+          handler.result
+        rescue LoadError
+          # Fallback if SAX2 is not available
+          require 'rexml/document'
+          doc = REXML::Document.new(xml_string)
+          handler = SaxHandler.new(&block)
+          # 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.result
+        end
+
+        def supports_streaming?
+          true
+        end
+
+        protected
+
+        def supports_xpath?
+          true
+        end
+
+        def supports_namespaces?
+          true
+        end
+
+        def supports_validation?
+          false
+        end
+      end
+
+      # SAX handler for REXML streaming
+      class SaxHandler
+        attr_reader :result, :elements_processed, :text_nodes_processed
+
+        def initialize(&block)
+          @block = block
+          @elements_processed = 0
+          @text_nodes_processed = 0
+          @result = nil
+        end
+
+        def start_element(uri, localname, qname, attributes)
+          @elements_processed += 1
+          @block&.call(:start_element, { name: qname, attributes: attributes })
+        end
+
+        def characters(text)
+          return if text.strip.empty?
+
+          @text_nodes_processed += 1
+          @block&.call(:text, text)
+        end
+
+        def end_element(uri, localname, qname)
+          @block&.call(:end_element, { name: qname })
+        end
+      end
+
+      # Include SAX2Listener if available
+      begin
+        require 'rexml/sax2listener'
+        SaxHandler.include(::REXML::SAX2Listener)
+      rescue LoadError
+        # SAX2Listener not available, handler works without it
+      end
+    end
+  end
+end

data/lib/serialbench/serializers.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'serializers/base_serializer'
+
+# XML Serializers
+require_relative 'serializers/xml/base_xml_serializer'
+require_relative 'serializers/xml/rexml_serializer'
+require_relative 'serializers/xml/ox_serializer'
+require_relative 'serializers/xml/nokogiri_serializer'
+require_relative 'serializers/xml/oga_serializer'
+require_relative 'serializers/xml/libxml_serializer'
+
+# JSON Serializers
+require_relative 'serializers/json/base_json_serializer'
+require_relative 'serializers/json/json_serializer'
+require_relative 'serializers/json/oj_serializer'
+require_relative 'serializers/json/yajl_serializer'
+
+# TOML Serializers
+require_relative 'serializers/toml/base_toml_serializer'
+require_relative 'serializers/toml/toml_rb_serializer'
+require_relative 'serializers/toml/tomlib_serializer'
+
+module Serialbench
+  module Serializers
+    # Registry of all available serializers
+    SERIALIZERS = {
+      xml: [
+        Xml::RexmlSerializer,
+        Xml::OxSerializer,
+        Xml::NokogiriSerializer,
+        Xml::OgaSerializer,
+        Xml::LibxmlSerializer
+      ],
+      json: [
+        Json::JsonSerializer,
+        Json::OjSerializer,
+        Json::YajlSerializer
+      ],
+      toml: [
+        Toml::TomlRbSerializer,
+        Toml::TomlibSerializer
+      ]
+    }.freeze
+
+    def self.all
+      SERIALIZERS.values.flatten
+    end
+
+    def self.for_format(format)
+      SERIALIZERS[format.to_sym] || []
+    end
+
+    def self.available_for_format(format)
+      for_format(format).select { |serializer_class| serializer_class.new.available? }
+    end
+
+    def self.available
+      all.select { |serializer_class| serializer_class.new.available? }
+    end
+  end
+end

data/lib/serialbench/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Serialbench
+  VERSION = '0.1.0'
+end

data/lib/serialbench.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'serialbench/version'
+require_relative 'serialbench/serializers'
+require_relative 'serialbench/benchmark_runner'
+require_relative 'serialbench/result_merger'
+require_relative 'serialbench/cli'
+require_relative 'serialbench/result_formatter'
+require_relative 'serialbench/chart_generator'
+require_relative 'serialbench/memory_profiler'
+
+module Serialbench
+  class Error < StandardError; end
+
+  # Supported serialization formats
+  FORMATS = %i[xml json toml].freeze
+
+  def self.run_benchmarks(formats: FORMATS, options: {})
+    runner = BenchmarkRunner.new(formats: formats, **options)
+    runner.run_all_benchmarks
+  end
+
+  def self.available_serializers(format = nil)
+    runner = BenchmarkRunner.new
+    if format
+      runner.serializers_for_format(format)
+    else
+      runner.all_serializers
+    end
+  end
+
+  def self.generate_reports(results)
+    result_merger = Serialbench::ResultMerger.new
+    result_merger.generate_all_reports(results)
+  end
+
+  def self.generate_reports_from_data(data_file)
+    require 'json'
+    data = JSON.parse(File.read(data_file), symbolize_names: true)
+    generate_reports(data)
+  end
+end

data/serialbench.gemspec

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'lib/serialbench/version'
+
+all_files_in_git = Dir.chdir(File.expand_path(__dir__)) do
+  `git ls-files -z`.split("\x0")
+end
+
+Gem::Specification.new do |spec|
+  spec.name = 'serialbench'
+  spec.version = Serialbench::VERSION
+  spec.authors = ['Ribose']
+  spec.email = ['open.source@ribose.com']
+
+  spec.summary = 'Comprehensive serialization benchmarking tool for Ruby'
+  spec.description = 'A benchmarking suite for comparing performance of various serialization libraries in Ruby, including XML, JSON, and TOML parsers/generators.'
+  spec.homepage = 'https://github.com/metanorma/serialbench'
+  spec.license = 'BSD-2-Clause'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.7.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['bug_tracker_uri'] = "#{spec.homepage}/issues"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = all_files_in_git
+               .reject { |f| f.match(%r{\A(?:spec|features|bin|\.)/}) }
+
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Runtime dependencies
+  spec.add_dependency 'benchmark-ips', '~> 2.10'
+  spec.add_dependency 'memory_profiler', '~> 1.0'
+  spec.add_dependency 'thor', '~> 1.2'
+
+  # XML serializers (optional)
+  spec.add_dependency 'libxml-ruby', '~> 4.0'
+  spec.add_dependency 'nokogiri', '~> 1.15'
+  spec.add_dependency 'oga', '~> 3.4'
+  spec.add_dependency 'ox', '~> 2.14'
+
+  # JSON serializers (optional)
+  spec.add_dependency 'oj', '~> 3.13'
+  spec.add_dependency 'yajl-ruby', '~> 1.4'
+
+  # TOML serializers (optional)
+  spec.add_dependency 'tomlib', '~> 0.6'
+  spec.add_dependency 'toml-rb', '~> 2.2'
+end