serialbench 0.2.0 → 0.4.0

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

@@ -19,41 +19,20 @@ module Serialbench
           generate(object, options)
         end
 
+        def capabilities
+          super | Set.new(%i[arrays_of_tables inline_tables multiline_strings])
+        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?
+            comments: supports?(:comments),
+            arrays_of_tables: supports?(:arrays_of_tables),
+            inline_tables: supports?(:inline_tables),
+            multiline_strings: supports?(:multiline_strings)
           }
         end
 
-        def supports_generation?
-          true
-        end
-
-        def supports_streaming?
-          # TOML is typically not streamed due to its structure
-          false
-        end
-
-        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'

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

@@ -31,22 +31,6 @@ module Serialbench
           require 'toml-rb'
           TomlRB.dump(object)
         end
-
-        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

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

@@ -28,10 +28,6 @@ module Serialbench
           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?
 

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

@@ -31,24 +31,8 @@ module Serialbench
           raise NotImplementedError, 'tomlrb gem does not support TOML generation/dumping'
         end
 
-        def supports_generation?
-          false
-        end
-
-        def supports_comments?
-          false
-        end
-
-        def supports_arrays_of_tables?
-          true
-        end
-
-        def supports_inline_tables?
-          true
-        end
-
-        def supports_multiline_strings?
-          true
+        def capabilities
+          Set.new(%i[dom parse arrays_of_tables inline_tables multiline_strings])
         end
       end
     end

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

@@ -23,37 +23,21 @@ module Serialbench
           generate(document, options)
         end
 
-        # XML-specific features
+        def capabilities
+          super | Set.new(%i[namespaces])
+        end
+
+        # XML-specific features derive from the capability set
         def features
           {
-            xpath: supports_xpath?,
-            namespaces: supports_namespaces?,
-            validation: supports_validation?,
-            streaming: supports_streaming?,
-            stax: supports_stax?
+            xpath: supports?(:xpath),
+            namespaces: supports?(:namespaces),
+            validation: supports?(:validation),
+            streaming: supports?(:sax) || supports?(:streaming),
+            stax: supports?(:stax)
           }
         end
 
-        def supports_stax?
-          false
-        end
-
-        def supports_generation?
-          true
-        end
-
-        def supports_xpath?
-          false
-        end
-
-        def supports_namespaces?
-          true
-        end
-
-        def supports_validation?
-          false
-        end
-
         # Check if the XML library is available
         def available?
           return @available if defined?(@available)

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

@@ -12,11 +12,13 @@ module Serialbench
 
         def parse(xml_string)
           require 'leptris'
+          require 'leptris/xml'
           Leptris::XML.parse(xml_string)
         end
 
         def generate(data)
           require 'leptris'
+          require 'leptris/xml'
           if data.is_a?(Leptris::XML::Document) || data.is_a?(Leptris::XML::Node)
             data.to_xml(indent: 2)
           else
@@ -26,6 +28,7 @@ module Serialbench
 
         def parse_streaming(xml_string, &block)
           require 'leptris'
+          require 'leptris/xml'
 
           handler = StreamingHandler.new(&block)
           parser = Leptris::XML::SAX::Parser.new(handler)
@@ -33,28 +36,27 @@ module Serialbench
           handler.elements_processed
         end
 
-        def supports_streaming?
-          true
+        def capabilities
+          super | Set.new(%i[xpath sax stax])
         end
 
-        def supports_xpath?
-          true
+        def xpath_query(document, expression)
+          require 'leptris'
+          require 'leptris/xml'
+          result = document.xpath(expression)
+          result.size
         end
 
         # leptris-ruby >= 1.6 exposes Leptris::XML::Pull, a StAX-style
         # cursor (one event per #next). Declared by gem version so the
         # check never triggers the FFI library load.
-        def supports_stax?
-          spec = Gem.loaded_specs['leptris'] || Gem::Specification.find_by_name('leptris')
-          !spec.nil? && spec.version >= Gem::Version.new('1.6.0')
-        rescue Gem::LoadError
-          false
-        end
+
 
         def version
           return 'unknown' unless available?
 
           require 'leptris'
+          require 'leptris/xml'
           Leptris::VERSION
         end
 
@@ -70,6 +72,7 @@ module Serialbench
 
           @available = begin
             require 'leptris'
+          require 'leptris/xml'
             Leptris::XML.parse('<probe/>')
             true
           rescue StandardError, LoadError

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

@@ -38,17 +38,12 @@ module Serialbench
           handler.elements_processed
         end
 
-        def supports_xpath?
-          true
+        def capabilities
+          super | Set.new(%i[xpath stax sax])
         end
 
-        # The binding exposes a pull-parser cursor (XML::Reader)
-        def supports_stax?
-          true
-        end
-
-        def supports_streaming?
-          true
+        def xpath_query(document, expression)
+          document.find(expression).size
         end
 
         def version

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

@@ -38,17 +38,12 @@ module Serialbench
           handler.elements_processed
         end
 
-        def supports_xpath?
-          true
+        def capabilities
+          super | Set.new(%i[xpath sax stax])
         end
 
-        # The binding exposes a pull-parser cursor (XML::Reader)
-        def supports_stax?
-          true
-        end
-
-        def supports_streaming?
-          true
+        def xpath_query(document, expression)
+          document.xpath(expression).size
         end
 
         def version

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

@@ -38,14 +38,16 @@ module Serialbench
           handler.elements_processed
         end
 
-        def supports_xpath?
-          true
+        def capabilities
+          super | Set.new(%i[xpath sax])
         end
 
-        def supports_streaming?
-          true
+        def xpath_query(document, expression)
+          document.xpath(expression).size
         end
 
+
+
         def version
           return 'unknown' unless available?
 

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

@@ -29,8 +29,8 @@ module Serialbench
           handler.elements_processed
         end
 
-        def supports_streaming?
-          true
+        def capabilities
+          super | Set.new(%i[sax])
         end
 
         def version

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

@@ -73,20 +73,13 @@ module Serialbench
           handler.result
         end
 
-        def supports_streaming?
-          false
+        def capabilities
+          super | Set.new(%i[xpath])
         end
 
-        def supports_xpath?
-          true
-        end
-
-        def supports_namespaces?
-          true
-        end
-
-        def supports_validation?
-          false
+        def xpath_query(document, expression)
+          require 'rexml/xpath'
+          REXML::XPath.match(document, expression).size
         end
 
         private

data/lib/serialbench/serializers/yaml/base_yaml_serializer.rb

@@ -11,12 +11,8 @@ module Serialbench
           :yaml
         end
 
-        def supports_streaming?
-          false # Most YAML parsers don't support streaming
-        end
-
         def features
-          { streaming: supports_streaming? }
+          { streaming: supports?(:sax) || supports?(:streaming) }
         end
 
         # Default YAML generation options
@@ -39,10 +35,6 @@ module Serialbench
           raise NotImplementedError, 'Streaming not supported by this YAML serializer'
         end
 
-        def supports_generation?
-          true
-        end
-
         private
 
         def require_library(library_name)

data/lib/serialbench/serializers/yaml/syck_serializer.rb

@@ -68,14 +68,6 @@ module Serialbench
           end
         end
 
-        def supports_streaming?
-          false
-        end
-
-        def features
-          %w[parsing generation legacy]
-        end
-
         def description
           'Legacy YAML parser (Ruby < 1.9.3)'
         end

data/lib/serialbench/test_data.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+module Serialbench
+  # Fixture documents for every format x size the benchmark engine measures.
+  class TestData
+    def self.load(config)
+      new(config).load
+    end
+
+    def initialize(config)
+      @config = config
+    end
+
+    def load
+      @config.data_sizes.each_with_object({}) do |size, data|
+        data[size] = @config.formats.each_with_object({}) do |format, formats|
+          formats[format] = fixture_file(size, format) || generate("#{size}.#{format}")
+        end
+      end
+    end
+
+    private
+
+    def fixture_file(size, format)
+      path = "test_data/#{size}.#{format}"
+      File.read(path) if File.exist?(path)
+    end
+
+    def generate(key)
+      case key
+      when 'small.xml' then generate_small_xml
+      when 'medium.xml' then generate_medium_xml
+      when 'large.xml' then generate_large_xml
+      when 'small.json' then generate_small_json
+      when 'medium.json' then generate_medium_json
+      when 'large.json' then generate_large_json
+      when 'small.yaml' then generate_small_yaml
+      when 'medium.yaml' then generate_medium_yaml
+      when 'large.yaml' then generate_large_yaml
+      when 'small.toml' then generate_small_toml
+      when 'medium.toml' then generate_medium_toml
+      when 'large.toml' then generate_large_toml
+      else raise ArgumentError, "no test data generator for #{key}"
+      end
+    end
+
+    # Shared data structure generators
+    def small_test_data_structure
+      {
+        config: {
+          database: {
+            host: 'localhost',
+            port: 5432,
+            name: 'myapp',
+            user: 'admin',
+            password: 'secret'
+          },
+          cache: {
+            enabled: true,
+            ttl: 3600
+          }
+        }
+      }
+    end
+
+    def medium_test_data_structure
+      {
+        users: (1..1000).map do |i|
+          {
+            id: i,
+            name: "User #{i}",
+            email: "user#{i}@example.com",
+            created_at: "2023-01-#{(i % 28) + 1}T10:00:00Z",
+            profile: {
+              age: 20 + (i % 50),
+              city: "City #{i % 100}",
+              preferences: {
+                theme: i.even? ? 'dark' : 'light',
+                notifications: (i % 3).zero?
+              }
+            }
+          }
+        end
+      }
+    end
+
+    def large_test_data_structure
+      {
+        dataset: {
+          header: {
+            created: '2023-01-01T00:00:00Z',
+            count: 10_000,
+            format: 'data'
+          },
+          records: (1..10_000).map do |i|
+            {
+              id: i,
+              timestamp: "2023-01-01T#{format('%02d', i % 24)}:#{format('%02d', i % 60)}:#{format('%02d', i % 60)}Z",
+              data: {
+                field1: "Value #{i}",
+                field2: i * 2,
+                field3: (i % 100).zero? ? 'special' : 'normal',
+                nested: [
+                  "Item #{i}-1",
+                  "Item #{i}-2",
+                  "Item #{i}-3"
+                ]
+              },
+              metadata: {
+                source: 'generator',
+                version: '1.0',
+                checksum: i.to_s(16)
+              }
+            }
+          end
+        }
+      }
+    end
+
+    # XML test data generators
+    def generate_small_xml
+      data = small_test_data_structure
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <config>
+          <database>
+            <host>#{data[:config][:database][:host]}</host>
+            <port>#{data[:config][:database][:port]}</port>
+            <name>#{data[:config][:database][:name]}</name>
+            <user>#{data[:config][:database][:user]}</user>
+            <password>#{data[:config][:database][:password]}</password>
+          </database>
+          <cache>
+            <enabled>#{data[:config][:cache][:enabled]}</enabled>
+            <ttl>#{data[:config][:cache][:ttl]}</ttl>
+          </cache>
+        </config>
+      XML
+    end
+
+    def generate_medium_xml
+      data = medium_test_data_structure
+      users = data[:users].map do |user|
+        <<~USER
+          <user id="#{user[:id]}">
+            <name>#{user[:name]}</name>
+            <email>#{user[:email]}</email>
+            <created_at>#{user[:created_at]}</created_at>
+            <profile>
+              <age>#{user[:profile][:age]}</age>
+              <city>#{user[:profile][:city]}</city>
+              <preferences>
+                <theme>#{user[:profile][:preferences][:theme]}</theme>
+                <notifications>#{user[:profile][:preferences][:notifications]}</notifications>
+              </preferences>
+            </profile>
+          </user>
+        USER
+      end.join
+
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <users>
+          #{users}
+        </users>
+      XML
+    end
+
+    def generate_large_xml
+      data = large_test_data_structure
+      records = data[:dataset][:records].map do |record|
+        nested_items = record[:data][:nested].map { |item| "    <item>#{item}</item>" }.join("\n")
+        <<~RECORD
+            <record id="#{record[:id]}">
+              <timestamp>#{record[:timestamp]}</timestamp>
+              <data>
+                <field1>#{record[:data][:field1]}</field1>
+                <field2>#{record[:data][:field2]}</field2>
+                <field3>#{record[:data][:field3]}</field3>
+                <nested>
+          #{nested_items}
+                </nested>
+              </data>
+              <metadata>
+                <source>#{record[:metadata][:source]}</source>
+                <version>#{record[:metadata][:version]}</version>
+                <checksum>#{record[:metadata][:checksum]}</checksum>
+              </metadata>
+            </record>
+        RECORD
+      end.join
+
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <dataset>
+          <header>
+            <created>#{data[:dataset][:header][:created]}</created>
+            <count>#{data[:dataset][:header][:count]}</count>
+            <format>xml</format>
+          </header>
+          <records>
+            #{records}
+          </records>
+        </dataset>
+      XML
+    end
+
+    # JSON test data generators
+    def generate_small_json
+      JSON.generate(small_test_data_structure)
+    end
+
+    def generate_medium_json
+      JSON.generate(medium_test_data_structure)
+    end
+
+    def generate_large_json
+      data = large_test_data_structure
+      data[:dataset][:header][:format] = 'json'
+      JSON.generate(data)
+    end
+
+    # YAML test data generators
+    def generate_small_yaml
+      small_test_data_structure.to_yaml
+    end
+
+    def generate_medium_yaml
+      medium_test_data_structure.to_yaml
+    end
+
+    def generate_large_yaml
+      data = large_test_data_structure
+      data[:dataset][:header][:format] = 'yaml'
+      data.to_yaml
+    end
+
+    # TOML test data generators
+    def generate_small_toml
+      data = small_test_data_structure
+      <<~TOML
+        [config]
+
+        [config.database]
+        host = "#{data[:config][:database][:host]}"
+        port = #{data[:config][:database][:port]}
+        name = "#{data[:config][:database][:name]}"
+        user = "#{data[:config][:database][:user]}"
+        password = "#{data[:config][:database][:password]}"
+
+        [config.cache]
+        enabled = #{data[:config][:cache][:enabled]}
+        ttl = #{data[:config][:cache][:ttl]}
+      TOML
+    end
+
+    def generate_medium_toml
+      data = medium_test_data_structure
+      # Use smaller dataset for TOML due to verbosity
+      users = data[:users].first(100)
+      users.map do |user|
+        <<~USER
+          [[users]]
+          id = #{user[:id]}
+          name = "#{user[:name]}"
+          email = "#{user[:email]}"
+          created_at = "#{user[:created_at]}"
+
+          [users.profile]
+          age = #{user[:profile][:age]}
+          city = "#{user[:profile][:city]}"
+
+          [users.profile.preferences]
+          theme = "#{user[:profile][:preferences][:theme]}"
+          notifications = #{user[:profile][:preferences][:notifications]}
+        USER
+      end.join("\n")
+    end
+
+    def generate_large_toml
+      data = large_test_data_structure
+      # Use smaller dataset for TOML due to verbosity
+      records = data[:dataset][:records].first(1000)
+      records_toml = records.map do |record|
+        <<~RECORD
+          [[dataset.records]]
+          id = #{record[:id]}
+          timestamp = "#{record[:timestamp]}"
+
+          [dataset.records.data]
+          field1 = "#{record[:data][:field1]}"
+          field2 = #{record[:data][:field2]}
+          field3 = "#{record[:data][:field3]}"
+          nested = #{record[:data][:nested].inspect}
+
+          [dataset.records.metadata]
+          source = "#{record[:metadata][:source]}"
+          version = "#{record[:metadata][:version]}"
+          checksum = "#{record[:metadata][:checksum]}"
+        RECORD
+      end.join("\n")
+
+      <<~TOML
+        [dataset]
+
+        [dataset.header]
+        created = "#{data[:dataset][:header][:created]}"
+        count = #{records.length}
+        format = "toml"
+
+        #{records_toml}
+      TOML
+    end
+  end
+end

data/lib/serialbench/version.rb

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