rubohash 0.1.1 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21ae00543eb4f8f3b4a94616f1d730355e92635fdd95c5a0febc31b80fe2ae5f
-  data.tar.gz: 87b6ff9172dd54bce6fecd3af1b3ed739fc3e3887b13502ae349de934f5c765c
+  metadata.gz: 7dfd304b72e037e11bf35ba9061a2158e19bc73965aac68ec0ca3ca08b3867ef
+  data.tar.gz: bf91a387bca0176f56b1f6e21f2ad58bd5d7179e30985003c1878a1baac096c2
 SHA512:
-  metadata.gz: 03ee912152ae61bd84a5451c9f9f103cbdb0a620f5b35748d3a5aa47b2fa47718fe82af05185668d9ce5e2eced161fba045305cbc5baad6a7d6c4fe016233541
-  data.tar.gz: e5ceb38b5d5b72213dc8e6ddcb608cc35af29af30bcd4cb309403ba59df255de597837aa2791a5b6ecdd8108317d5d7e8d89a388f290afb444cd63fa96339519
+  metadata.gz: 9c9e10adc7548488c402c58cceb6f81870cef25b0e1de0003e1bd07c06f6a5e61f5ab82975d4924e37a6b28dd44be7262c3c1ab48c6766014cd8338813859f52
+  data.tar.gz: 55bfaab91a0408813dbe8a3909833baee8b3ed1f246b9c967c20f21a24a4a3693e4632ea17606606b9e46251186c070d550509578d0a49b83ee16820b7896e93

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubohash (0.1.1)
+    rubohash (0.1.4)
       mini_magick (~> 4.9.4)
 
 GEM

data/README.md

@@ -20,6 +20,20 @@ By default, generated files are written to `./output` from your current working
 
 For local development in this repository, you can use `./bin/build.sh`.
 
+## Benchmark
+
+To measure how long image generation takes locally:
+
+```sh
+bundle exec ruby benchmark/image_generation.rb
+bundle exec rake benchmark:image_generation
+ITERATIONS=25 WARMUP=5 bundle exec ruby benchmark/image_generation.rb
+SCENARIOS=without_background bundle exec ruby benchmark/image_generation.rb
+BATCH_SIZES=1,10,100 bundle exec ruby benchmark/image_generation.rb
+```
+
+The benchmark reports batch totals plus per-image averages in milliseconds for each scenario and batch size.
+
 ## Usage
 
 From Ruby code:

data/Rakefile

@@ -3,4 +3,11 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
+namespace :benchmark do
+  desc 'Benchmark image generation'
+  task :image_generation do
+    ruby 'benchmark/image_generation.rb'
+  end
+end
+
 task default: :spec

data/benchmark/image_generation.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+
+require 'tmpdir'
+require_relative '../lib/rubohash'
+
+module Rubohash
+  class BenchmarkRunner
+    DEFAULT_ITERATIONS = 10
+    DEFAULT_WARMUP = 2
+    DEFAULT_SCENARIOS = %w[with_background without_background].freeze
+    DEFAULT_BATCH_SIZES = [1, 10, 100].freeze
+
+    def initialize(iterations:, warmup:, scenarios:, batch_sizes:)
+      @iterations = iterations
+      @warmup = warmup
+      @scenarios = scenarios
+      @batch_sizes = batch_sizes
+    end
+
+    def call
+      print_header
+      @scenarios.each { |scenario| run_scenario(scenario) }
+    end
+
+    private
+
+    def run_scenario(scenario)
+      use_background = scenario == 'with_background'
+
+      with_benchmark_config(use_background: use_background) do
+        @warmup.times do |index|
+          image = build_image("warmup-#{scenario}-#{index}")
+          image.destroy!
+        end
+
+        puts "scenario: #{scenario}"
+        @batch_sizes.each do |batch_size|
+          durations = benchmark_batch(scenario, batch_size)
+          print_report(batch_size, durations)
+        end
+        puts
+      end
+    end
+
+    def build_image(seed)
+      Rubohash::Factory.new(seed).assemble
+    end
+
+    def benchmark_batch(scenario, batch_size)
+      durations = []
+
+      @iterations.times do |index|
+        started_at = monotonic_time
+        batch_size.times do |offset|
+          seed = "benchmark-#{scenario}-#{batch_size}-#{index}-#{offset}"
+          image = build_image(seed)
+          image.destroy!
+        end
+        durations << ((monotonic_time - started_at) * 1000.0)
+      end
+
+      durations
+    end
+
+    def with_benchmark_config(use_background:)
+      original = {
+        mounted: Rubohash.mounted,
+        use_background: Rubohash.use_background,
+        robot_output_path: Rubohash.robot_output_path
+      }
+
+      Dir.mktmpdir('rubohash-benchmark') do |tmpdir|
+        Rubohash.configure do |config|
+          config.mounted = true
+          config.use_background = use_background
+          config.robot_output_path = tmpdir
+        end
+
+        yield
+      ensure
+        Rubohash.configure do |config|
+          config.mounted = original[:mounted]
+          config.use_background = original[:use_background]
+          config.robot_output_path = original[:robot_output_path]
+        end
+      end
+    end
+
+    def print_header
+      puts 'Rubohash image generation benchmark'
+      puts "iterations: #{@iterations}"
+      puts "warmup: #{@warmup}"
+      puts "batch_sizes: #{@batch_sizes.join(', ')}"
+      puts
+    end
+
+    def print_report(batch_size, durations)
+      sorted = durations.sort
+      total = durations.sum
+      average = total / durations.length
+      median = percentile(sorted, 50)
+      p95 = percentile(sorted, 95)
+      per_image_average = average / batch_size
+
+      puts "  batch_size: #{batch_size}"
+      puts format('    total:         %.2f ms', total)
+      puts format('    avg_batch:     %.2f ms', average)
+      puts format('    avg_per_image: %.2f ms', per_image_average)
+      puts format('    median_batch:  %.2f ms', median)
+      puts format('    p95_batch:     %.2f ms', p95)
+      puts format('    min/max:       %.2f / %.2f ms', sorted.first, sorted.last)
+    end
+
+    def percentile(sorted_values, rank)
+      return sorted_values.first if sorted_values.length == 1
+
+      index = ((rank / 100.0) * (sorted_values.length - 1)).round
+      sorted_values[index]
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end
+
+iterations = Integer(ENV.fetch('ITERATIONS', Rubohash::BenchmarkRunner::DEFAULT_ITERATIONS))
+warmup = Integer(ENV.fetch('WARMUP', Rubohash::BenchmarkRunner::DEFAULT_WARMUP))
+scenarios = ENV.fetch('SCENARIOS', Rubohash::BenchmarkRunner::DEFAULT_SCENARIOS.join(',')).split(',').map(&:strip)
+batch_sizes = ENV.fetch('BATCH_SIZES', Rubohash::BenchmarkRunner::DEFAULT_BATCH_SIZES.join(',')).split(',').map { |value| Integer(value.strip) }
+
+unknown_scenarios = scenarios - Rubohash::BenchmarkRunner::DEFAULT_SCENARIOS
+abort("Unknown scenarios: #{unknown_scenarios.join(', ')}") unless unknown_scenarios.empty?
+abort('BATCH_SIZES must only contain positive integers') unless batch_sizes.all?(&:positive?)
+
+Rubohash::BenchmarkRunner.new(
+  iterations: iterations,
+  warmup: warmup,
+  scenarios: scenarios,
+  batch_sizes: batch_sizes
+).call

data/lib/rubohash/factory.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'tempfile'
 
 # Rubohash namespace
 module Rubohash
@@ -49,34 +50,32 @@ module Rubohash
 
     # List directories for the given path
     def list_directories(path)
-      Dir.entries(path).select do |entry|
+      self.class.directory_cache[path] ||= Dir.entries(path).select do |entry|
         next if %w[. ..].include?(entry)
         File.directory?(File.join(path, entry))
-      end.sort
+      end.sort.freeze
     end
 
     # List files from the given path
     def list_files(path)
-      Dir.glob("#{path}/**").reject do |entry|
+      self.class.file_cache[path] ||= Dir.glob("#{path}/**").reject do |entry|
         next if %w[. ..].include?(entry)
         File.directory?(entry)
-      end.sort
+      end.sort.freeze
     end
 
     # Get the random parts for the robot
     # eyes, ears, etc...
     def get_list_of_files(path)
-      # Get all subdirectories
-      # sets/set1/blue
-      directories = Dir.glob("#{path}/**").select do |entry|
+      directories = self.class.part_directory_cache[path] ||= Dir.glob("#{path}/**").select do |entry|
         next if %w[. ..].include?(entry)
         File.directory?(entry)
-      end.sort
+      end.sort.freeze
 
       # This is to index into the proper place in the hash array
       iter = 4
       directories.map do |dir|
-        files = Dir.entries(dir).reject { |k| %w[. ..].include?(k) }.sort
+        files = self.class.directory_file_cache[dir] ||= Dir.entries(dir).reject { |k| %w[. ..].include?(k) }.sort.freeze
         sample = files[my_hash_array[iter] % files.length]
         iter += 1
         [dir, sample].join('/')
@@ -112,52 +111,88 @@ module Rubohash
 
       roboparts = get_list_of_files(robot.my_set).sort_by { |k| k.split('#')[1] }
       robot.parts = roboparts
+      background = selected_background_for(robot)
 
-      image = MiniMagick::Image.open(roboparts.first)
-      image = image.resize('1024x1024')
+      output_path, tempfile = output_destination_for(robot)
+      compose_image(roboparts, background, output_path)
 
-      roboparts.each do |part|
-        img = MiniMagick::Image.open(part)
-        img = img.resize('1024x1024')
-        image = image.composite(img) do |c|
-          c.compose 'Over'
-        end
-      end
+      robot.name = string
+      robot.my_digest = my_digest
+
+      return load_image(output_path, tempfile: tempfile) if Rubohash.mounted
+
+      puts "Writing Robot: '#{output_path}'"
+      robot
+    end
+
+    def self.directory_cache
+      @directory_cache ||= {}
+    end
+
+    def self.file_cache
+      @file_cache ||= {}
+    end
+
+    def self.part_directory_cache
+      @part_directory_cache ||= {}
+    end
+
+    def self.directory_file_cache
+      @directory_file_cache ||= {}
+    end
 
-      if Rubohash.use_background
-        # use the hash bits to get the actual sample
-        background_files = list_files(robot.my_background_set)
+    private
 
-        # Set background itself from hash bits
-        background_hash_key = my_hash_array[3] % background_files.size
-        background = background_files[background_hash_key]
+    def compose_image(parts, background, output_path)
+      MiniMagick::Tool::Convert.new do |convert|
+        if background
+          convert << '('
+          convert << background
+          convert << '-resize' << '1024x1024!'
+          convert << ')'
+        else
+          convert << '-size' << '1024x1024'
+          convert << 'canvas:none'
+        end
 
-        bg = MiniMagick::Image.open(background)
-        bg = bg.resize('1024x1024')
-        image = image.composite(bg) do |c|
-          c.compose 'Dst_Over'
-          c.resize '300x300'
+        parts.each do |part|
+          convert << '('
+          convert << part
+          convert << '-resize' << '1024x1024!'
+          convert << ')'
         end
-      else
-        image = image.resize('300x300')
+
+        convert << '-background' << 'none'
+        convert << '-layers' << 'flatten'
+
+        convert << '-resize' << '300x300!'
+        convert << output_path
       end
+    end
 
-      robot.name = string
-      robot.my_digest = my_digest
+    def selected_background_for(robot)
+      return unless Rubohash.use_background
 
+      background_files = list_files(robot.my_background_set)
+      background_hash_key = my_hash_array[3] % background_files.size
+      background_files[background_hash_key]
+    end
+
+    def output_destination_for(robot)
       if Rubohash.mounted
-        # Just return the image
-        image
+        tempfile = Tempfile.new([robot.name || 'rubohash', ".#{my_format}"])
+        [tempfile.path, tempfile]
       else
         FileUtils.mkdir_p(Rubohash.robot_output_path)
-        path = File.join(Rubohash.robot_output_path, "#{robot.name}.#{self.my_format}")
-        puts "Writing Robot: '#{path}'"
-        image.write path
-        robot
+        [File.join(Rubohash.robot_output_path, "#{string}.#{my_format}"), nil]
       end
     end
 
-    private
+    def load_image(path, tempfile: nil)
+      image = MiniMagick::Image.new(path)
+      image.instance_variable_set(:@rubohash_tempfile, tempfile) if tempfile
+      image
+    end
 
     # Build out robot attributes
     def build_robot_attrs

data/lib/rubohash/version.rb

@@ -1,5 +1,5 @@
 # Rubohash namespace
 module Rubohash
   # The version number of this gem
-  VERSION = '0.1.1'.freeze
+  VERSION = '0.1.4'.freeze
 end

data/rubohash.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Mark Holmberg']
   spec.email         = ['mark.holmberg@icentris.com']
 
-  spec.summary       = 'It generates SHA512 Robot Images.'
+  spec.summary       = 'Ruby adaptation of robohash.org.'
   spec.description   = 'Ruby adaptation of robohash.org'
   spec.homepage      = 'https://github.com/nedzib/rubohash'
   spec.license       = 'MIT'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubohash
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.4
 platform: ruby
 authors:
 - Mark Holmberg
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-18 00:00:00.000000000 Z
+date: 2026-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_magick
@@ -125,6 +125,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmark/image_generation.rb
 - bin/build.sh
 - bin/clean.sh
 - bin/console
@@ -969,5 +970,5 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
-summary: It generates SHA512 Robot Images.
+summary: Ruby adaptation of robohash.org.
 test_files: []