serialbench 0.1.0

data/lib/serialbench/serializers/base_serializer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Serialbench
+  module Serializers
+    class BaseSerializer
+      def initialize
+        # Override in subclasses
+      end
+
+      def available?
+        raise NotImplementedError, 'Subclasses must implement #available?'
+      end
+
+      def name
+        raise NotImplementedError, 'Subclasses must implement #name'
+      end
+
+      def version
+        raise NotImplementedError, 'Subclasses must implement #version'
+      end
+
+      def format
+        raise NotImplementedError, 'Subclasses must implement #format'
+      end
+
+      def parse(data)
+        raise NotImplementedError, 'Subclasses must implement #parse'
+      end
+
+      def generate(object)
+        raise NotImplementedError, 'Subclasses must implement #generate'
+      end
+
+      def stream_parse(data, &block)
+        # Default implementation falls back to regular parsing
+        # Override in subclasses that support streaming
+        result = parse(data)
+        yield(:document, result) if block_given?
+        result
+      end
+
+      def supports_streaming?
+        # Override in subclasses that support streaming
+        false
+      end
+
+      protected
+
+      def require_library(library_name)
+        require library_name
+        true
+      rescue LoadError
+        false
+      end
+
+      def get_version(constant_path)
+        constant_path.split('::').reduce(Object) { |obj, const| obj.const_get(const) }
+      rescue NameError
+        'unknown'
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/json/base_json_serializer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../base_serializer'
+
+module Serialbench
+  module Serializers
+    module Json
+      class BaseJsonSerializer < BaseSerializer
+        def format
+          :json
+        end
+
+        # JSON-specific methods
+        def parse_object(json_string)
+          parse(json_string)
+        end
+
+        def generate_json(object, options = {})
+          generate(object, options)
+        end
+
+        # JSON-specific features
+        def features
+          {
+            pretty_print: supports_pretty_print?,
+            streaming: supports_streaming?,
+            symbol_keys: supports_symbol_keys?,
+            custom_types: supports_custom_types?
+          }
+        end
+
+        protected
+
+        def supports_pretty_print?
+          true
+        end
+
+        def supports_symbol_keys?
+          false
+        end
+
+        def supports_custom_types?
+          false
+        end
+
+        # Subclasses should override this to specify their library name
+        def library_require_name
+          raise NotImplementedError, 'Subclasses must implement #library_require_name'
+        end
+
+        public
+
+        # Check if the JSON library is available
+        def available?
+          return @available if defined?(@available)
+
+          @available = begin
+            require library_require_name
+            true
+          rescue LoadError
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/json/json_serializer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'base_json_serializer'
+
+module Serialbench
+  module Serializers
+    module Json
+      class JsonSerializer < BaseJsonSerializer
+        def available?
+          require_library('json')
+        end
+
+        def name
+          'json'
+        end
+
+        def version
+          require 'json'
+          JSON::VERSION
+        rescue LoadError, NameError
+          'built-in'
+        end
+
+        def parse(json_string)
+          require 'json'
+          JSON.parse(json_string)
+        end
+
+        def generate(object, options = {})
+          require 'json'
+          if options[:pretty]
+            JSON.pretty_generate(object)
+          else
+            JSON.generate(object)
+          end
+        end
+
+        def supports_streaming?
+          false
+        end
+
+        protected
+
+        def supports_pretty_print?
+          true
+        end
+
+        def supports_symbol_keys?
+          false
+        end
+
+        def supports_custom_types?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/json/oj_serializer.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative 'base_json_serializer'
+
+module Serialbench
+  module Serializers
+    module Json
+      class OjSerializer < BaseJsonSerializer
+        def available?
+          require_library('oj')
+        end
+
+        def name
+          'oj'
+        end
+
+        def version
+          require 'oj'
+          Oj::VERSION
+        rescue LoadError, NameError
+          'unknown'
+        end
+
+        def parse(json_string)
+          require 'oj'
+          Oj.load(json_string)
+        end
+
+        def generate(object, options = {})
+          require 'oj'
+          if options[:pretty]
+            Oj.dump(object, indent: 2)
+          else
+            Oj.dump(object)
+          end
+        end
+
+        def stream_parse(json_string, &block)
+          require 'oj'
+          # Oj supports streaming through saj (Simple API for JSON)
+          handler = StreamHandler.new(&block)
+          Oj.saj_parse(handler, json_string)
+          handler.result
+        rescue LoadError, NoMethodError
+          # Fallback to regular parsing if streaming not available
+          super
+        end
+
+        def supports_streaming?
+          require 'oj'
+          Oj.respond_to?(:saj_parse)
+        rescue LoadError
+          false
+        end
+
+        protected
+
+        def supports_pretty_print?
+          true
+        end
+
+        def supports_symbol_keys?
+          true
+        end
+
+        def supports_custom_types?
+          true
+        end
+      end
+
+      # Stream handler for Oj SAJ parsing
+      class StreamHandler
+        attr_reader :result
+
+        def initialize(&block)
+          @block = block
+          @result = nil
+        end
+
+        def hash_start(key)
+          @block&.call(:hash_start, key)
+        end
+
+        def hash_end(key)
+          @block&.call(:hash_end, key)
+        end
+
+        def array_start(key)
+          @block&.call(:array_start, key)
+        end
+
+        def array_end(key)
+          @block&.call(:array_end, key)
+        end
+
+        def add_value(value, key)
+          @block&.call(:value, { key: key, value: value })
+        end
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/json/yajl_serializer.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'base_json_serializer'
+
+module Serialbench
+  module Serializers
+    module Json
+      class YajlSerializer < BaseJsonSerializer
+        def name
+          'yajl'
+        end
+
+        def parse(json_string)
+          require 'yajl'
+          Yajl::Parser.parse(json_string)
+        end
+
+        def generate(data)
+          require 'yajl'
+          Yajl::Encoder.encode(data)
+        end
+
+        def parse_streaming(json_string, &block)
+          require 'yajl'
+
+          parser = Yajl::Parser.new
+          parser.on_parse_complete = block if block
+
+          # Parse the JSON string
+          result = parser.parse(json_string)
+
+          # Return number of top-level objects processed
+          case result
+          when Array
+            result.length
+          when Hash
+            1
+          else
+            1
+          end
+        end
+
+        def supports_streaming?
+          true
+        end
+
+        def version
+          return 'unknown' unless available?
+
+          require 'yajl'
+          # YAJL doesn't have a VERSION constant, try to get gem version
+          begin
+            Gem.loaded_specs['yajl-ruby']&.version&.to_s || 'unknown'
+          rescue StandardError
+            'unknown'
+          end
+        end
+
+        protected
+
+        def library_require_name
+          'yajl'
+        end
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/toml/base_toml_serializer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../base_serializer'
+
+module Serialbench
+  module Serializers
+    module Toml
+      class BaseTomlSerializer < BaseSerializer
+        def format
+          :toml
+        end
+
+        # TOML-specific methods
+        def parse_config(toml_string)
+          parse(toml_string)
+        end
+
+        def generate_toml(object, options = {})
+          generate(object, options)
+        end
+
+        # TOML-specific features
+        def features
+          {
+            comments: supports_comments?,
+            arrays_of_tables: supports_arrays_of_tables?,
+            inline_tables: supports_inline_tables?,
+            multiline_strings: supports_multiline_strings?
+          }
+        end
+
+        def supports_streaming?
+          # TOML is typically not streamed due to its structure
+          false
+        end
+
+        protected
+
+        def supports_comments?
+          false
+        end
+
+        def supports_arrays_of_tables?
+          true
+        end
+
+        def supports_inline_tables?
+          true
+        end
+
+        def supports_multiline_strings?
+          true
+        end
+
+        # Subclasses should override this to specify their library name
+        def library_require_name
+          raise NotImplementedError, 'Subclasses must implement #library_require_name'
+        end
+
+        public
+
+        # Check if the TOML library is available
+        def available?
+          return @available if defined?(@available)
+
+          @available = begin
+            require library_require_name
+            true
+          rescue LoadError
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/toml/toml_rb_serializer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'base_toml_serializer'
+
+module Serialbench
+  module Serializers
+    module Toml
+      class TomlRbSerializer < BaseTomlSerializer
+        def available?
+          require_library('toml-rb')
+        end
+
+        def name
+          'toml-rb'
+        end
+
+        def version
+          require 'toml-rb'
+          # toml-rb doesn't expose a VERSION constant, so we'll use gem version
+          Gem.loaded_specs['toml-rb']&.version&.to_s || 'unknown'
+        rescue LoadError, NameError
+          'unknown'
+        end
+
+        def parse(toml_string)
+          require 'toml-rb'
+          TomlRB.parse(toml_string)
+        end
+
+        def generate(object, options = {})
+          require 'toml-rb'
+          TomlRB.dump(object)
+        end
+
+        protected
+
+        def supports_comments?
+          false
+        end
+
+        def supports_arrays_of_tables?
+          true
+        end
+
+        def supports_inline_tables?
+          true
+        end
+
+        def supports_multiline_strings?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/toml/tomlib_serializer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'base_toml_serializer'
+
+module Serialbench
+  module Serializers
+    module Toml
+      class TomlibSerializer < BaseTomlSerializer
+        def name
+          'tomlib'
+        end
+
+        def parse(toml_string)
+          require 'tomlib'
+          Tomlib.load(toml_string)
+        end
+
+        def generate(data)
+          require 'tomlib'
+          Tomlib.dump(data)
+        end
+
+        def parse_streaming(toml_string, &block)
+          # TOML doesn't typically support streaming parsing
+          # Parse the entire document and yield it
+          result = parse(toml_string)
+          block&.call(result) if block
+          1 # Return 1 document processed
+        end
+
+        def supports_streaming?
+          false # TOML is typically parsed as a whole document
+        end
+
+        def version
+          return 'unknown' unless available?
+
+          require 'tomlib'
+          Tomlib::VERSION
+        end
+
+        protected
+
+        def library_require_name
+          'tomlib'
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../base_serializer'
+
+module Serialbench
+  module Serializers
+    module Xml
+      class BaseXmlSerializer < BaseSerializer
+        def format
+          :xml
+        end
+
+        # XML-specific methods
+        def parse_dom(xml_string)
+          parse(xml_string)
+        end
+
+        def parse_sax(xml_string, &block)
+          stream_parse(xml_string, &block)
+        end
+
+        def generate_xml(document, options = {})
+          generate(document, options)
+        end
+
+        # XML-specific features
+        def features
+          {
+            xpath: supports_xpath?,
+            namespaces: supports_namespaces?,
+            validation: supports_validation?,
+            streaming: supports_streaming?
+          }
+        end
+
+        protected
+
+        def supports_xpath?
+          false
+        end
+
+        def supports_namespaces?
+          true
+        end
+
+        def supports_validation?
+          false
+        end
+
+        # Subclasses should override this to specify their library name
+        def library_require_name
+          raise NotImplementedError, 'Subclasses must implement #library_require_name'
+        end
+
+        public
+
+        # Check if the XML library is available
+        def available?
+          return @available if defined?(@available)
+
+          @available = begin
+            require library_require_name
+            true
+          rescue LoadError
+            false
+          end
+        end
+      end
+    end
+  end
+end