serialbench 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed5cf6538b0a64c26b9d9c0739b943f750f30476aa27a94c5b87aae98c203b55
-  data.tar.gz: 3d1e7eb5c8f71c4052014729bd6dbbf4417a68339065a7a934ea1e5a3ef82a3b
+  metadata.gz: e90d8b6ebc8deebf308b1e02214b978597d0d2a9699c3845ebf6405953d733b7
+  data.tar.gz: 4cc9e46139f7054919657d66fd26ed6b40430856e0bdd317f2677451bc1bf715
 SHA512:
-  metadata.gz: 8bd0e7a6052712f3a49c4656e6aa663cd4db2215c9f9ebc3ac8379b7f258f78e488fdfc46bb52a8e6e9d89cc07ef78fa4fbebe6f0471881b679d40d5ab42284d
-  data.tar.gz: 5441d7d92266df86976a78dd4fb68acf8c491147c799b06aa9e1a67ac5bd382dfd27547505e4566483a9657f983bc7bb0ffb5280cc17089de61a8b070fe5677b
+  metadata.gz: 38652e0714893c8ed9590fe1a7ef29c9c6e94cdbdcb0104d9190d12bad1c95f8635680b904d66b9edda72f55f7c037ce5e18894bf5fb66d5b88db21ba2dcaa3d
+  data.tar.gz: 728e8ee7c92138afdfd722cfb93ef7463c22e7d1c8882e5d83507dba7861637addd659e489df21c91a80a45680fc532eb0898f9ffed9ce48402a604962b73c85

data/.github/workflows/benchmark.yml

@@ -111,26 +111,6 @@ jobs:
       - name: Install gems
         run: bundle install
 
-      - name: Build libleptris from source (Ubuntu 22.04)
-        if: matrix.platform == 'ubuntu-22.04' || matrix.platform == 'ubuntu-22.04-arm'
-        run: |
-          LEPTRIS_VERSION=$(bundle exec ruby -e "print Gem::Specification.find_by_name('leptris').version")
-          LEPTRIS_TAG=$(curl -s "https://api.github.com/repos/leptris/leptris/tags?per_page=100" \
-            | grep -oE '"v[0-9]+\.[0-9]+\.[0-9]+"' | tr -d '"' | sort -V \
-            | awk -v v="v${LEPTRIS_VERSION}" '$0 <= v' | tail -1)
-          echo "Building libleptris ${LEPTRIS_VERSION} from tag ${LEPTRIS_TAG}"
-          test -n "${LEPTRIS_TAG}"
-          curl -sL "https://github.com/leptris/leptris/archive/refs/tags/${LEPTRIS_TAG}.tar.gz" | tar xz
-          ln -s "leptris-${LEPTRIS_TAG#v}" "leptris-${LEPTRIS_VERSION}"
-          cmake -S "leptris-${LEPTRIS_VERSION}" -B /tmp/leptris-build \
-            -DLEPTRIS_BUILD_SHARED=ON -DLEPTRIS_BUILD_STATIC=OFF -DBUILD_TESTING=OFF \
-            -DLEPTRIS_BUILD_CLI=OFF -DLEPTRIS_BUILD_BENCHMARKS=OFF -DLEPTRIS_BUILD_MAN_PAGES=OFF \
-            -DLEPTRIS_ENABLE_UTF8PROC=OFF -DLEPTRIS_ENABLE_ICONV=OFF
-          cmake --build /tmp/leptris-build -j"$(nproc)"
-          LIBLEPTRIS=$(find /tmp/leptris-build -name 'libleptris.so*' -type f | head -1)
-          echo "LEPTRIS_LIB_PATH=${LIBLEPTRIS}" >> "$GITHUB_ENV"
-        shell: bash
-
       - name: Create environment config
         run: |
           mkdir -p config/environments

data/Gemfile

@@ -12,7 +12,7 @@ unless Gem.win_platform? && RUBY_PLATFORM.include?('aarch64')
   gem 'libxml-ruby'
 end
 
-gem 'leptris', '1.9.0'  # pin to latest git tag; newer gems expect APIs not in v1.9.0 source builds    # Needs the libleptris shared library (LEPTRIS_LIB_PATH or system install)
+gem 'leptris', '1.9.35'  # precompiled platform gems bundle libleptris (darwin/linux/mingw)
 gem 'benchmark'  # Removed from stdlib in Ruby 4.0
 gem 'base64'  # Required for Ruby 3.4+
 gem 'lutaml-model', '~> 0.7'

data/lib/serialbench/benchmark_runner.rb

@@ -145,313 +145,28 @@ module Serialbench
 
       case type_name
       when 'generation'
-        serializers.select(&:supports_generation?)
+        serializers.select { |s| s.supports?(:generate) }
       when 'streaming'
-        serializers.select(&:supports_streaming?)
+        serializers.select { |s| s.supports?(:sax) || s.supports?(:streaming) }
+      when 'xpath'
+        serializers.select { |s| s.supports?(:xpath) }
       else
         serializers
       end
     end
 
     def get_iterations_for_size(size)
-      @benchmark_config.iterations.send(size.to_s)
-    end
-
-    def load_test_data
-      # Determine which data sizes to load based on configuration
-      data_sizes = @benchmark_config.data_sizes
-
-      # Initialize test data structure
-      @test_data = {}
-      data_sizes.each { |size| @test_data[size] = {} }
-
-      # Generate data for each format and size
-      @benchmark_config.formats.each do |format|
-        data_sizes.each do |size|
-          @test_data[size][format] = generate_test_data(format, size)
-        end
+      iterations = @benchmark_config.iterations
+      case size.to_s
+      when 'small' then iterations.small
+      when 'medium' then iterations.medium
+      when 'large' then iterations.large
+      else raise ArgumentError, "no iteration count configured for #{size}"
       end
-
-      # Try to load real test files if they exist
-      data_sizes.each do |size|
-        @benchmark_config.formats.each do |format|
-          file_path = "test_data/#{size}.#{format}"
-          @test_data[size][format] = File.read(file_path) if File.exist?(file_path)
-        end
-      end
-    end
-
-    def generate_test_data(format, size)
-      method_name = "generate_#{size}_#{format}"
-      send(method_name)
-    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
+    def load_test_data
+      @test_data = TestData.load(@benchmark_config)
     end
   end
 end

data/lib/serialbench/cli.rb

@@ -6,7 +6,6 @@ require_relative 'cli/environment_cli'
 require_relative 'cli/benchmark_cli'
 require_relative 'cli/ruby_build_cli'
 require_relative 'cli/validate_cli'
-require_relative 'cli/resultset_cli'
 
 module Serialbench
   # Main CLI entry point for the new object-oriented command structure
@@ -58,10 +57,6 @@ module Serialbench
             serialbench benchmark create my-benchmark
             serialbench benchmark execute my-benchmark.yml
 
-            # Create a result set for comparison
-
-            # Generate static sites
-            serialbench benchmark build-site results/my-benchmark
 
           For detailed help on any command, use:
             serialbench COMMAND help

data/lib/serialbench/models/result_store.rb

@@ -8,7 +8,6 @@ module Serialbench
     class ResultStore
       DEFAULT_BASE_PATH = 'results'
       RUNS_PATH = 'runs'
-      SETS_PATH = 'sets'
 
       attr_reader :base_path
 
@@ -34,27 +33,6 @@ module Serialbench
         limit ? runs.first(limit) : runs
       end
 
-      # Run set management
-      def sets_path
-        File.join(@base_path, SETS_PATH)
-      end
-
-      def find_resultsets(tags: nil, limit: nil)
-        resultsets = ResultSet.find_all(sets_path)
-
-        resultsets = resultsets.select { |resultset| (Array(tags) - resultset.tags).empty? } if tags
-
-        limit ? resultsets.first(limit) : resultsets
-      end
-
-      # Convenience methods
-      def create_resultset(name, run_platform_strings, metadata: {})
-        run_paths = run_platform_strings.map { |ps| File.join(runs_path, ps) }
-        resultset = ResultSet.create(name, run_paths, metadata: metadata)
-        save_resultset(resultset)
-        resultset
-      end
-
       # Validation
       def validate_structure
         errors = []
@@ -62,7 +40,6 @@ module Serialbench
         # Check base structure
         errors << "Base path does not exist: #{@base_path}" unless Dir.exist?(@base_path)
         errors << "Runs directory does not exist: #{runs_path}" unless Dir.exist?(runs_path)
-        errors << "Sets directory does not exist: #{sets_path}" unless Dir.exist?(sets_path)
 
         # Validate individual runs
         if Dir.exist?(runs_path)
@@ -78,20 +55,6 @@ module Serialbench
           end
         end
 
-        # Validate result sets
-        if Dir.exist?(sets_path)
-          Dir.glob(File.join(sets_path, '*')).each do |set_path|
-            next unless Dir.exist?(set_path)
-
-            begin
-              resultset = ResultSet.load(set_path)
-              resultset.validate!
-            rescue StandardError => e
-              errors << "Invalid result set at #{set_path}: #{e.message}"
-            end
-          end
-        end
-
         errors
       end
 
@@ -101,7 +64,6 @@ module Serialbench
 
       def ensure_results_directory
         FileUtils.mkdir_p(runs_path) unless Dir.exist?(runs_path)
-        FileUtils.mkdir_p(sets_path) unless Dir.exist?(sets_path)
       end
     end
   end

data/lib/serialbench/models.rb

@@ -6,7 +6,6 @@ require_relative 'models/result'
 require_relative 'models/result_store'
 require_relative 'models/benchmark_config'
 require_relative 'models/environment_config'
-require_relative 'models/result_set'
 
 module Serialbench
   module Models
@@ -46,9 +45,5 @@ module Serialbench
     def self.create_run(platform_string, benchmark_data, metadata: {})
       Result.create(platform_string, benchmark_data, metadata: metadata)
     end
-
-    def self.create_resultset(name, run_paths_or_objects, metadata: {})
-      ResultSet.create(name, run_paths_or_objects, metadata: metadata)
-    end
   end
 end

data/lib/serialbench/serializers/base_serializer.rb

@@ -46,10 +46,6 @@ module Serialbench
         capabilities.include?(capability)
       end
 
-      def supports_streaming?
-        supports?(:sax) || supports?(:streaming)
-      end
-
       def require_library(library_name)
         require library_name
         true

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

@@ -19,32 +19,20 @@ module Serialbench
           generate(object, options)
         end
 
+        def capabilities
+          super | Set.new(%i[pretty_print])
+        end
+
         # JSON-specific features
         def features
           {
-            pretty_print: supports_pretty_print?,
-            streaming: supports_streaming?,
-            symbol_keys: supports_symbol_keys?,
-            custom_types: supports_custom_types?
+            pretty_print: supports?(:pretty_print),
+            streaming: supports?(:sax) || supports?(:streaming),
+            symbol_keys: supports?(:symbol_keys),
+            custom_types: supports?(:custom_types)
           }
         end
 
-        def supports_generation?
-          true
-        end
-
-        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'

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

@@ -34,22 +34,6 @@ module Serialbench
             JSON.generate(object)
           end
         end
-
-        def supports_streaming?
-          false
-        end
-
-        def supports_pretty_print?
-          true
-        end
-
-        def supports_symbol_keys?
-          false
-        end
-
-        def supports_custom_types?
-          false
-        end
       end
     end
   end

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

@@ -46,23 +46,8 @@ module Serialbench
           super
         end
 
-        def supports_streaming?
-          require 'oj'
-          Oj.respond_to?(:saj_parse)
-        rescue LoadError
-          false
-        end
-
-        def supports_pretty_print?
-          true
-        end
-
-        def supports_symbol_keys?
-          true
-        end
-
-        def supports_custom_types?
-          true
+        def capabilities
+          super | Set.new(%i[symbol_keys custom_types sax])
         end
       end
 

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

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

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?