pool_of_entropy 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9282759abb1c13fd70a45b27da5f58030107bc23
-  data.tar.gz: 88da59e58548d584b72df4640be40be61aef9b37
+SHA256:
+  metadata.gz: 4cf2426e234e3234f458defe0d59aadda7b95e08b3161a3edc5c79fed8f829dc
+  data.tar.gz: 5573c75b6a5a565296c4271c1e32acc0e14989996bc3b85f660f94072f0e7d38
 SHA512:
-  metadata.gz: b158c97ffc614e6f40c5f769812a5f1441877e96c429e525875639c18f3c1a6f8699341bf81c062981e7eac2a2e986120718029facdb8bfe135e5ad8fc140d7f
-  data.tar.gz: c68191705fce736800291804d24d30c46e74be13906cde6cae5e46983ae1afaeaeb6d72aa5b4e4cb72110b06d2d9751b32034c3e2424381378f13d8fdf08518a
+  metadata.gz: 6bb69625454353f670b3fe6e12a8cf8d70b2bf11aeeb145e6d3fea93a3a967f8bccb0a985bc3060b6c856a7d794bcc83a9c206f87a2b10f99ccc2af989b95c37
+  data.tar.gz: e03b6919f0ca301e74c3c7255a4e8302381f763e04f199dcc144d5e0a3601b560b9bdd70769e62dd74625e2d3e481b7eb9185c913814c7c29d4508284ea65cd0

data/.github/workflows/rspec.yml

@@ -0,0 +1,23 @@
+name: RSpec
+
+on:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version:
+          - '3.3'
+          - '3.4'
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - run: bundle exec rubocop
+      - run: bundle exec rspec

data/.rubocop.yml

@@ -0,0 +1,18 @@
+plugins:
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 3.3
+  NewCops: enable
+
+Layout/LineLength:
+  Max: 120
+  
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*
+  AllowedMethods:
+    - context
+    - describe
+    - shared_examples

data/Gemfile

@@ -1,4 +1,14 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
-# Dependencies are in pool_of_entropy.gemspec
 gemspec
+
+gem 'bundler', '>= 2.5', '< 5'
+gem 'rake', '~> 13.2'
+gem 'rspec', '~> 3.13'
+gem 'rubocop', '~> 1.88'
+gem 'rubocop-rake', '~> 0.7'
+gem 'rubocop-rspec', '~> 3.10'
+gem 'simplecov', '~> 1.0'
+gem 'yard', '~> 0.9.37'

data/README.md

@@ -1,9 +1,5 @@
 # PoolOfEntropy
 [![Gem Version](https://badge.fury.io/rb/pool_of_entropy.png)](http://badge.fury.io/rb/pool_of_entropy)
-[![Build Status](https://travis-ci.org/neilslater/pool_of_entropy.png?branch=master)](http://travis-ci.org/neilslater/pool_of_entropy)
-[![Coverage Status](https://coveralls.io/repos/neilslater/pool_of_entropy/badge.png?branch=master)](https://coveralls.io/r/neilslater/pool_of_entropy?branch=master)
-[![Code Climate](https://codeclimate.com/github/neilslater/pool_of_entropy.png)](https://codeclimate.com/github/neilslater/pool_of_entropy)
-[![Dependency Status](https://gemnasium.com/neilslater/pool_of_entropy.png)](https://gemnasium.com/neilslater/pool_of_entropy)
 
 PoolOfEntropy is a pseudo random number generator (PRNG) based on secure hashes,
 intended to bring back the feeling of 'personal agency' that some gamers may feel when rolling

data/Rakefile

@@ -1,10 +1,12 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
 
-desc "PoolOfEntropy unit tests"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'PoolOfEntropy unit tests'
 RSpec::Core::RakeTask.new(:test) do |t|
-  t.pattern = "spec/*_spec.rb"
+  t.pattern = 'spec/**/*_spec.rb'
   t.verbose = false
 end
 
-task :default => [:test]
+task default: [:test]

data/lib/pool_of_entropy/core_prng.rb

@@ -1,165 +1,171 @@
+# frozen_string_literal: true
+
 require 'digest/sha2'
 require 'securerandom'
 
-# This class implements a random number generator based on SHA-512
-#
-# An object of the class has internal state that is modified on each call to
-# #update or any #read_... method (internally the #read_... methods call #update).
-# The #read_... methods generate a pseudo-random number from the current
-# state pool using SHA-512 and use it in the return value. It is not feasible to
-# determine the internal state from the pseudo-random data received, and not
-# possible to manipulate results from the PRNG in a predictable manner without
-# knowing the internal state.
-#
-# @example Using default internal state, initialised using SecureRandom.random_bytes
-#  prng = PoolOfEntropy::CorePRNG.new
-#  prng.read_bytes
-#  # E.g. => "]\x12\x9E\xF5\x17\xF3\xC2\x1A\x15\xDFu]\x95\nd\x12"
-#  prng.read_hex
-#  # E.g. => "a0e00d2848242ec49e0a15ef411ba647"
-#  prng.read_bignum
-#  # E.g. => 33857278877368906880463811096418580004
-#  prng.read_float
-#  # E.g. => 0.6619838265836278
-#  prng.generate_integer( 20 )
-#  # E.g. => 7
-#
-
-class PoolOfEntropy::CorePRNG
-
-  # Creates a new random number source. All parameters are optional.
-  # @param [Integer] size Number of 64-byte blocks, between 1 and 256 (16KB)
-  # @param [String] initial_state Sets contents of state pool (default uses SecureRandom)
-  # @param [Integer] mix_block_id
-  # @return [PoolOfEntropy::CorePRNG]
-  def initialize size = 1, initial_state = SecureRandom.random_bytes( 64 * Integer(size) ), mix_block_id = 0
-    @size = validate_size( size )
-    @state = validate_state( initial_state, size )
-    @mix_block_id = Integer( mix_block_id ) % @size
-  end
-
-  # The number of 64-byte blocks used in the internal state pool.
-  # @return [Integer]
-  attr_reader :size
-
-  # Identifies the next 64-byte block in the pool that will be altered
-  # by a read or update process.
-  # @return [Integer]
-  attr_reader :mix_block_id
-
-  # A clone of the internal state pool. In combination with #mix_block_id, describes
-  # the whole PRNG. If this value is supplied to an end user, then they can easily
-  # predict future values of the PRNG.
-  # @return [PoolOfEntropy::CorePRNG]
-  def state
-    @state.clone
-  end
-
-  # The clone of a PoolOfEntropy::CorePRNG object includes separate copy of internal state
-  # @return [PoolOfEntropy::CorePRNG]
-  def clone
-    PoolOfEntropy::CorePRNG.new( self.size, self.state, self.mix_block_id )
-  end
+class PoolOfEntropy
+  # This class implements a random number generator based on SHA-512
+  #
+  # An object of the class has internal state that is modified on each call to
+  # #update or any #read_... method (internally the #read_... methods call #update).
+  # The #read_... methods generate a pseudo-random number from the current
+  # state pool using SHA-512 and use it in the return value. It is not feasible to
+  # determine the internal state from the pseudo-random data received, and not
+  # possible to manipulate results from the PRNG in a predictable manner without
+  # knowing the internal state.
+  #
+  # @example Using default internal state, initialised using SecureRandom.random_bytes
+  #  prng = PoolOfEntropy::CorePRNG.new
+  #  prng.read_bytes
+  #  # E.g. => "]\x12\x9E\xF5\x17\xF3\xC2\x1A\x15\xDFu]\x95\nd\x12"
+  #  prng.read_hex
+  #  # E.g. => "a0e00d2848242ec49e0a15ef411ba647"
+  #  prng.read_bignum
+  #  # E.g. => 33857278877368906880463811096418580004
+  #  prng.read_float
+  #  # E.g. => 0.6619838265836278
+  #  prng.generate_integer( 20 )
+  #  # E.g. => 7
+  #
+  class CorePRNG
+    # Creates a new random number source. All parameters are optional.
+    # @param [Integer] size Number of 64-byte blocks, between 1 and 256 (16KB)
+    # @param [String] initial_state Sets contents of state pool (default uses SecureRandom)
+    # @param [Integer] mix_block_id
+    # @return [PoolOfEntropy::CorePRNG]
+    def initialize(size = 1, initial_state = SecureRandom.random_bytes(64 * Integer(size)), mix_block_id = 0)
+      @size = validate_size(size)
+      @state = validate_state(initial_state, size)
+      @mix_block_id = Integer(mix_block_id) % @size
+    end
 
-  # Mixes supplied data into the curent state. This is called
-  # internally by #read_... methods as well.
-  # @param [String] data Data to be mixed. Note empty string '' and nil are equivalent and *do* change the state.
-  # @return [nil]
-  def update data
-    new_block = Digest::SHA512.digest( @state + data.to_s )
-    @state[64*@mix_block_id,64] = new_block
-    @mix_block_id = (@mix_block_id + 1) % @size
-    nil
-  end
+    # The number of 64-byte blocks used in the internal state pool.
+    # @return [Integer]
+    attr_reader :size
+
+    # Identifies the next 64-byte block in the pool that will be altered
+    # by a read or update process.
+    # @return [Integer]
+    attr_reader :mix_block_id
+
+    # A clone of the internal state pool. In combination with #mix_block_id, describes
+    # the whole PRNG. If this value is supplied to an end user, then they can easily
+    # predict future values of the PRNG.
+    # @return [PoolOfEntropy::CorePRNG]
+    def state
+      @state.clone
+    end
 
-  # Statistically flat distribution of 128 bits (16 bytes)
-  # @param [Array<String>] adjustments mixed in using SHA-512, so that they affect return value, but not internal state
-  # @return [String] 16 characters in ASCII-8BIT encoding
-  def read_bytes *adjustments
-    raw_digest = Digest::SHA512.digest( @state )
-    self.update( raw_digest )
-    adjustments.compact.each do |adjust|
-      raw_digest = Digest::SHA512.digest( raw_digest + adjust )
+    # The clone of a PoolOfEntropy::CorePRNG object includes separate copy of internal state
+    # @return [PoolOfEntropy::CorePRNG]
+    def clone
+      PoolOfEntropy::CorePRNG.new(size, state, mix_block_id)
     end
-    fold_bits( fold_bits( raw_digest ) )
-  end
 
-  # Statistically flat distribution of 32 hex digits
-  # @param [Array<String>] adjustments mixed in using SHA-512, so that they affect return value, but not internal state
-  # @return [String] 32 hex digits
-  def read_hex *adjustments
-    read_bytes( *adjustments ).unpack('H*').first
-  end
+    # Mixes supplied data into the curent state. This is called
+    # internally by #read_... methods as well.
+    # @param [String] data Data to be mixed. Note empty string '' and nil are equivalent and *do* change the state.
+    # @return [nil]
+    def update(data)
+      new_block = Digest::SHA512.digest(@state + data.to_s)
+      @state[64 * @mix_block_id, 64] = new_block
+      @mix_block_id = (@mix_block_id + 1) % @size
+      nil
+    end
 
-  # Statistically flat distribution from range 0...2**128
-  # @param [Array<String>] adjustments mixed in using SHA-512, so that they affect return value, but not internal state
-  # @return [Bignum,Fixnum] between 0 and 0xffffffffffffffffffffffffffffffff
-  def read_bignum *adjustments
-    nums = read_bytes( *adjustments ).unpack('Q>*')
-    nums.inject(0) { |sum,v| (sum << 64) + v }
-  end
+    # Statistically flat distribution of 128 bits (16 bytes)
+    # @param [Array<String>] adjustments mixed in using SHA-512, so that they affect
+    #   the return value, but not internal state
+    # @return [String] 16 characters in ASCII-8BIT encoding
+    def read_bytes(*adjustments)
+      raw_digest = Digest::SHA512.digest(@state)
+      update(raw_digest)
+      adjustments.compact.each do |adjust|
+        raw_digest = Digest::SHA512.digest(raw_digest + adjust)
+      end
+      fold_bits(fold_bits(raw_digest))
+    end
 
-  # Statistically flat distribution from interval 0.0...1.0, with 53-bit precision
-  # @param [Array<String>] adjustments mixed in using SHA-512, so that they affect return value, but not internal state
-  # @return [Float] between 0.0 and 0.9999999999999999
-  def read_float *adjustments
-    num = read_bytes( *adjustments ).unpack('Q>*').first >> 11
-    num.to_f / 2 ** 53
-  end
+    # Statistically flat distribution of 32 hex digits
+    # @param [Array<String>] adjustments mixed in using SHA-512, so that they affect
+    #   the return value, but not internal state
+    # @return [String] 32 hex digits
+    def read_hex(*adjustments)
+      read_bytes(*adjustments).unpack1('H*')
+    end
 
-  # Statistically flat distribution from range (0...top).
-  # If necessary, it will read more data to ensure absolute fairness. This method
-  # can generate an unbiased distribution of Bignums up to roughly half the maximum bit size
-  # allowed by Ruby (i.e. much larger than 2**128 generated in a single read)
-  # @param [Fixnum,Bignum] top upper bound of distribution, not inclusive
-  # @param [Array<String>] adjustments mixed in using SHA-512, so that they affect return value, but not internal state
-  # @return [Fixnum,Bignum] between 0 and top-1 inclusive
-  def generate_integer top, *adjustments
-    power = 1
-    sum = 0
-    words = []
-
-    loop do
-      words = read_bytes( *adjustments ).unpack('L>*') if words.empty?
-      sum = 2**32 * sum + words.shift
-      power *= 2**32
-      lower_bound = sum * top / power
-      break lower_bound if lower_bound == ( (sum + 1) * top ) / power
+    # Statistically flat distribution from range 0...2**128
+    # @param [Array<String>] adjustments mixed in using SHA-512, so that they affect
+    #   the return value, but not internal state
+    # @return [Bignum,Fixnum] between 0 and 0xffffffffffffffffffffffffffffffff
+    def read_bignum(*adjustments)
+      nums = read_bytes(*adjustments).unpack('Q>*')
+      nums.inject(0) { |sum, v| (sum << 64) + v }
     end
-  end
 
-  private
+    # Statistically flat distribution from interval 0.0...1.0, with 53-bit precision
+    # @param [Array<String>] adjustments mixed in using SHA-512, so that they affect
+    #   the return value, but not internal state
+    # @return [Float] between 0.0 and 0.9999999999999999
+    def read_float(*adjustments)
+      num = read_bytes(*adjustments).unpack1('Q>*') >> 11
+      num.to_f / (2**53)
+    end
 
-  # Xors first half of a message with second half. Only works for messages
-  # which are multiples of 8 bytes long.
-  # @param [String] msg bytes to fold
-  # @return [String] folded message, half the length of original
-  def fold_bits msg
-    l = msg.length/2
-    folded_32bits = msg[0,l].unpack('L>*').zip( msg[l,l].unpack('L>*') ).map do |x,y|
-      x ^ y
+    # Statistically flat distribution from range (0...top).
+    # If necessary, it will read more data to ensure absolute fairness. This method
+    # can generate an unbiased distribution of Bignums up to roughly half the maximum bit size
+    # allowed by Ruby (i.e. much larger than 2**128 generated in a single read)
+    # @param [Fixnum,Bignum] top upper bound of distribution, not inclusive
+    # @param [Array<String>] adjustments mixed in using SHA-512, so that they affect
+    #   the return value, but not internal state
+    # @return [Fixnum,Bignum] between 0 and top-1 inclusive
+    def generate_integer(top, *adjustments)
+      power = 1
+      sum = 0
+      words = []
+
+      loop do
+        words = read_bytes(*adjustments).unpack('L>*') if words.empty?
+        sum = ((2**32) * sum) + words.shift
+        power *= 2**32
+        lower_bound = sum * top / power
+        break lower_bound if lower_bound == ((sum + 1) * top) / power
+      end
     end
-    folded_32bits.pack('L>*')
-  end
 
-  def validate_size i
-    size = Integer( i )
-    if size < 1 || size > 256
-      raise ArgumentError, "Size of pool must be in Range 1..256, got #{size}"
+    private
+
+    # Xors first half of a message with second half. Only works for messages
+    # which are multiples of 8 bytes long.
+    # @param [String] msg bytes to fold
+    # @return [String] folded message, half the length of original
+    def fold_bits(msg)
+      l = msg.length / 2
+      folded_32bits = msg[0, l].unpack('L>*').zip(msg[l, l].unpack('L>*')).map do |x, y|
+        x ^ y
+      end
+      folded_32bits.pack('L>*')
     end
-    size
-  end
 
-  def validate_state( initial_state, size )
-    unless initial_state.is_a? String
-      raise TypeError, "Initial state must be a String, got #{initial_state.inspect}"
+    def validate_size(value)
+      size = Integer(value)
+      raise ArgumentError, "Size of pool must be in Range 1..256, got #{size}" if size < 1 || size > 256
+
+      size
     end
-    state = initial_state.clone
-    state.force_encoding( 'BINARY' )
 
-    if state.size != size * 64
-      raise ArgumentError, "Initial state bad size - expected #{size * 64} bytes, got #{state.size} bytes"
+    def validate_state(initial_state, size)
+      raise TypeError, "Initial state must be a String, got #{initial_state.inspect}" unless initial_state.is_a? String
+
+      state = initial_state.clone
+      state.force_encoding('BINARY')
+
+      if state.size != size * 64
+        raise ArgumentError, "Initial state bad size - expected #{size * 64} bytes, got #{state.size} bytes"
+      end
+
+      state
     end
-    state
   end
 end

data/lib/pool_of_entropy/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class PoolOfEntropy
-  VERSION = "0.0.3"
+  VERSION = '0.0.5'
 end

data/lib/pool_of_entropy.rb

@@ -1,5 +1,7 @@
-require "pool_of_entropy/version"
-require "pool_of_entropy/core_prng"
+# frozen_string_literal: true
+
+require 'pool_of_entropy/version'
+require 'pool_of_entropy/core_prng'
 
 # This class models a random number generator that can mix user input into
 # the generation mechanism in a few different ways.
@@ -20,28 +22,23 @@ require "pool_of_entropy/core_prng"
 #    # E.g. => 12
 #    sleep 5
 #  end
-#
-
 class PoolOfEntropy
-
   # Creates a new random number source. All parameters are optional.
   # @param [Hash] options
   # @option options [Integer] :size, number of 512-bit (64 byte) blocks to use as internal state, defaults to 1
   # @option options [Boolean] :blank, if true then initial state is all zeroes, otherwise use SecureRandom
   # @option options [Array<String>] :seeds, if provided these are sent to #add_to_pool during initialize
   # @return [PoolOfEntropy]
-  def initialize options = {}
-    unless options.is_a? Hash
-      raise TypeError, "Expecting an options hash, got #{options.inspect}"
-    end
+  def initialize(options = {})
+    raise TypeError, "Expecting an options hash, got #{options.inspect}" unless options.is_a? Hash
 
-    size = size_from_options( options )
+    size = size_from_options(options)
 
-    initial_state = state_from_options( options, size )
+    initial_state = state_from_options(options, size)
 
-    @core_prng = CorePRNG.new( size, initial_state )
+    @core_prng = CorePRNG.new(size, initial_state)
 
-    seed_from_options( options )
+    seed_from_options(options)
 
     @next_modifier_queue = []
     @fixed_modifier = nil
@@ -50,7 +47,11 @@ class PoolOfEntropy
   # Cloning creates a deep copy with identical PRNG state and modifiers
   # @return [PoolOfEntropy]
   def clone
-    Marshal.load( Marshal.dump( self ) )
+    copy = super
+    copy.instance_variable_set(:@core_prng, @core_prng.clone)
+    copy.instance_variable_set(:@fixed_modifier, @fixed_modifier.clone) if @fixed_modifier
+    copy.instance_variable_set(:@next_modifier_queue, @next_modifier_queue.map(&:clone))
+    copy
   end
 
   # Same functionality as Kernel#rand or Random#rand, but using
@@ -58,19 +59,14 @@ class PoolOfEntropy
   # two modifiers that are in effect.
   # @param [Integer,Range] max if 0 then will return a Float
   # @return [Float,Fixnum,Bignum] type depends on value of max
-  def rand max = 0
-    if max.is_a? Range
-      bottom = max.first
-      top = max.last
-      return( nil ) if top < bottom
-      return bottom + generate_integer( ( top - bottom + 1 ) )
+  def rand(max = 0)
+    return rand_from_range(max) if max.is_a? Range
+
+    effective_max = max.to_i.abs
+    if effective_max.zero?
+      generate_float
     else
-      effective_max = max.to_i.abs
-      if effective_max == 0
-        return generate_float
-      else
-        return generate_integer( effective_max )
-      end
+      generate_integer(effective_max)
     end
   end
 
@@ -81,13 +77,13 @@ class PoolOfEntropy
   # affect the internal state of the data pool used by the generator.
   # @param [Array<String>] modifiers
   # @return [PoolOfEntropy] self
-  def modify_next *modifiers
+  def modify_next(*modifiers)
     modifiers.each do |modifier|
-      if modifier.nil?
-        @next_modifier_queue << nil
-      else
-        @next_modifier_queue << Digest::SHA512.digest( modifier.to_s )
-      end
+      @next_modifier_queue << if modifier.nil?
+                                nil
+                              else
+                                Digest::SHA512.digest(modifier.to_s)
+                              end
     end
     self
   end
@@ -100,11 +96,9 @@ class PoolOfEntropy
   # affect the internal state of the data pool used by the generator.
   # @param [String,nil] modifier
   # @return [PoolOfEntropy] self
-  def modify_all modifier
+  def modify_all(modifier)
     @fixed_modifier = modifier
-    unless @fixed_modifier.nil?
-      @fixed_modifier = Digest::SHA512.digest( @fixed_modifier.to_s )
-    end
+    @fixed_modifier = Digest::SHA512.digest(@fixed_modifier.to_s) unless @fixed_modifier.nil?
     self
   end
 
@@ -113,8 +107,8 @@ class PoolOfEntropy
   # from #rand() and cannot be undone.
   # @param [String] data
   # @return [PoolOfEntropy] self
-  def add_to_pool data
-    @core_prng.update( data )
+  def add_to_pool(data)
+    @core_prng.update(data)
     self
   end
 
@@ -128,45 +122,51 @@ class PoolOfEntropy
 
   private
 
+  def rand_from_range(range)
+    bottom = range.first
+    top = range.last
+    return nil if top < bottom
+
+    bottom + generate_integer(top - bottom + 1)
+  end
+
   def use_adjustments
-    [ @fixed_modifier, @next_modifier_queue.shift ].compact
+    [@fixed_modifier, @next_modifier_queue.shift].compact
   end
 
   def generate_float
-    @core_prng.read_float( *use_adjustments )
+    @core_prng.read_float(*use_adjustments)
   end
 
-  def generate_integer max
-    @core_prng.generate_integer( max, *use_adjustments )
+  def generate_integer(max)
+    @core_prng.generate_integer(max, *use_adjustments)
   end
 
-  def state_from_options( options, size )
+  def state_from_options(options, size)
     if options[:blank]
       "\x0" * size * 64
     else
-      SecureRandom.random_bytes( size * 64 )
+      SecureRandom.random_bytes(size * 64)
     end
   end
 
-  def size_from_options( options )
+  def size_from_options(options)
     size = 1
     if options[:size]
-      size = Integer( options[:size] )
-      if size < 1 || size > 256
-        raise ArgumentError, "Size of pool must be in Range 1..256, got #{size}"
-      end
+      size = Integer(options[:size])
+      raise ArgumentError, "Size of pool must be in Range 1..256, got #{size}" if size < 1 || size > 256
     end
     size
   end
 
-  def seed_from_options( options )
-    if options[:seeds]
-      unless options[:seeds].is_a? Array
-        raise TypeError, "Expected value for :seeds to be an Array, got #{options[:seeds].inspect}"
-      end
-      options[:seeds].each do |seed|
-        add_to_pool( seed )
-      end
+  def seed_from_options(options)
+    return unless options[:seeds]
+    unless options[:seeds].is_a? Array
+      raise TypeError, "Expected value for :seeds to be an Array, got #{options[:seeds].inspect}"
+    end
+
+    options[:seeds].each do |seed|
+      add_to_pool(seed)
     end
   end
 end