para_dice 0.6.0

data/lib/para_dice/faces/ranged.rb

@@ -0,0 +1,38 @@
+require 'virtus'
+module ParaDice
+  module Faces
+    # a module to be included into a ParaDice::Die or similar object.
+    # Uses a Range object to provide a faces, and provides special count and
+    # random_face options
+    module Ranged
+      include Virtus.module
+
+      # @!attribute range
+      #   return [Range]
+      attribute :range, Range, default: :quit_if_no_range
+
+      # @return [Fixnum] size of range
+      def face_count
+        range.size
+      end
+
+      # @note this can be an unexpectedly expensive action for large ranges,
+      #   please use carefully
+      # @return [Array<Fixnum>] result of range.to_a
+      def faces
+        @faces ||= range.to_a
+      end
+
+      # @param [nil,Random] random_face_rng defaults to self.rng
+      # @return [Fixnum] random element of range
+      def random_face(random_face_rng = rng)
+        random_face_rng.rand(range.size) + range.first
+      end
+
+      private
+      def quit_if_no_range
+        raise ArgumentError.new('no :range entry found in initialization hash')
+      end
+    end
+  end
+end

data/lib/para_dice/numbered_die.rb

@@ -0,0 +1,13 @@
+require 'para_dice/die'
+require 'para_dice/faces/ranged'
+module ParaDice
+  # a standard die like d6 d10, d20, d100 or exotic like d17, d32, d11-10, d100-999
+  class NumberedDie
+    include Die
+    include Faces::Ranged
+
+    def self.get(max)
+      self.new(name: "d#{max}", range: 1..max)
+    end
+  end
+end

data/lib/para_dice/poly_bag.rb

@@ -0,0 +1,31 @@
+require 'virtus' # TODO check on usage later
+
+require 'para_dice/bag'
+require 'para_dice/numbered_die'
+require 'para_dice/results/number'
+module ParaDice
+  # A ParaDice bag that has all of the standard dice: d6, d10, d10, and that you
+  # can add more like d33
+  class PolyBag
+    # contains all of the dice to start the bag with
+    DEFAULT_DICE    = [2, 3, 4, 6, 8, 10, 12, 20, 30, 100]
+    # the result stack that Bag will pass by default to cups.
+    DEFAULT_READERS = [Results::Number]
+
+    # generate a new poly bag with optional rng
+    # @param [nil, Random, #rand] random number generator to pass to all cups
+    #   (which will in turn pass it to each)
+    # @return [PolyBag]
+    def self.get(rng = nil)
+      a = ParaDice::Bag.new(name:            'Poly Dice',
+                            rng:             rng,
+                            default_readers: DEFAULT_READERS)
+
+      DEFAULT_DICE.each do |num|
+        die = NumberedDie.get(num)
+        a.add_die(die)
+      end
+      return a
+    end
+  end
+end

data/lib/para_dice/results/and_keep.rb

@@ -0,0 +1,34 @@
+module ParaDice
+  module Results
+    # Results class to implement a roll 5 and keep 3 style of play
+    class AndKeep
+      # @!attribute [rw] :default_keep
+      #   @return [Fixnum] the default number of dice to keep
+      # @!attribute [rw] :default_low_results
+      #   @return [Boolean] keep dice off of the low end of the order. false by default
+      # @!attribute [rw] :default_sort_by
+      #   @return [Proc] the sort by block defaults to passing the object through to sort
+      DEFAULT_SORT_BY = ->(obj) { obj }
+      attr_accessor :default_keep, :default_low_results, :default_sort_by
+      # @param [Regex,String] default_keep
+      def initialize(default_keep = nil)
+        @default_keep = default_keep
+      end
+
+      # @param [Array<#to_s>] faces
+      # @param [Regex,String] keep default: default_keep
+      # @param [Boolean] low_results if true take the bottom of the order
+      # @yield [obj] provides obj to call methods on to determine value for use
+      #   in Array.order_by.  Numbers sort easy, names are trickier
+      # @return [Array<String>]
+      def resolve(faces, keep = default_keep, low_results = false, &blk)
+        results_method = low_results ? :first : :last
+        if block_given?
+          faces.sort_by(&blk).to_a.send(results_method, keep)
+        else
+          faces.sort_by(&default_sort_by).to_a.send(results_method, keep)
+        end
+      end
+    end
+  end
+end

data/lib/para_dice/results/array.rb

@@ -0,0 +1,13 @@
+module ParaDice
+  module Results
+    # Results class to output the list of faces.  It's a Noop that sets the
+    #   Api for Results files
+    module Array
+      # @param [Array] faces
+      # @return array of faces passed in
+      def self.resolve(faces)
+        faces
+      end
+    end
+  end
+end

data/lib/para_dice/results/cancel_opposing.rb

@@ -0,0 +1,46 @@
+require 'para_dice/utility'
+
+module ParaDice
+  module Results
+    # Results class to have some faces cancel other faces out of the results,
+    #  can also be used to drop faces entirely by defining them as their own opposite
+    class CancelOpposing
+      # @!attribute rw default_opposing
+      #   default to DEFAULT_OPPOSING = []
+      #   @return [Array<Array>] list of pairs of faces that cancel each other out
+      #     use [['blank','blank']] as opposing to eliminate blank results
+      #     use [['good','bad'], ['hero','villain']] to have good and bad, heroes
+      #     villains to cancel each other out
+      attr_accessor :default_opposing
+
+      # set empty here so it will work if no values passed to it.
+      DEFAULT_OPPOSING = []
+      # @param [Array<Array>] opposing defaults to DEFAULT_OPPOSING=[]
+      def initialize(default_opposing = DEFAULT_OPPOSING)
+        @default_opposing = default_opposing
+      end
+
+      # @param [Array<#to_s>] faces
+      # @param [Array<Array>] opposing defaults to default_opposing
+      # @return [Array<String>]
+      def resolve(faces, opposing = default_opposing)
+        summary = Utility.to_summary(faces)
+        opposing.each do |one_face, another_face|
+          one_face     = one_face.to_s
+          another_face = another_face.to_s
+          next unless summary.key?(one_face) && summary.key?(another_face)
+          if summary[one_face] == summary[another_face]
+            summary.delete(one_face)
+            summary.delete(another_face)
+          else
+            low, high     = [one_face, another_face].sort_by { |e| summary[e] }
+            summary[high] -= summary[low]
+            summary.delete(low)
+          end
+        end
+
+        Utility.from_summary(summary)
+      end
+    end
+  end
+end

data/lib/para_dice/results/hash.rb

@@ -0,0 +1,14 @@
+require 'para_dice/utility'
+module ParaDice
+  module Results
+    # Results class to return a hash summary of a dice result
+    module Hash
+      # @param [Array] faces
+      # @return [Hash{Object=>Fixnum}]summary hash
+      # @see Utility#to_summary
+      def self.resolve(faces)
+        Utility.to_summary(faces)
+      end
+    end
+  end
+end

data/lib/para_dice/results/number.rb

@@ -0,0 +1,39 @@
+module ParaDice
+  module Results
+    # Number is meant to run a single operation across all faces of the results in
+    # order to do things like add up all of the results.  This class gets inserted
+    # as a result responder as opposed to the Module uses.  The default is to add all
+    # of the elements together and return the result
+
+    # @note this class could also be used for more complex operations using the
+    #   reduce with operator and initial values.  Blocks seem like another likely
+    #   refinement.  But I couldn't come with a reason to use them yet that didn't
+    #   seem more confusing than coding a new result resolver
+    class Number
+      # If not overridden the initial value is 0
+      DEFAULT_INITIAL  = 0
+      # If not overridden the operator is :+
+      DEFAULT_OPERATOR = :+
+      # @!attribute [rw] default_initial_value
+      #   @return [Numeric,Obj]
+      # @!attribute [rw] default_operator
+      #   @return [Symbol]
+      attr_accessor :default_initial_value, :default_operator
+
+      # @param [Numeric, Obj] default_operator
+      # @param [Symbol]  default_operator
+      def initialize(initial_val = DEFAULT_INITIAL, default_operator = DEFAULT_OPERATOR)
+        @default_initial_value = initial_val
+        @default_operator = default_operator
+      end
+
+      # @param [Array<Numeric,Object>] faces
+      # @param [Numeric,Object] initial value, defaults to DEFAULT_INITIAL = 0
+      # @param [Symbol] operator, defaults to DEFAULT_OPERATOR = :+
+      # @return [Numeric, Object] result of inject with faces, initial_value, and operator
+      def resolve(faces, initial_value = default_initial_value, operator = default_operator)
+        faces.inject(initial_value, operator)
+      end
+    end
+  end
+end

data/lib/para_dice/results/split_faces.rb

@@ -0,0 +1,23 @@
+module ParaDice
+  module Results
+    # Results class to take faces and split them given a string or regexp
+    class SplitFaces
+      # @!attribute default_split_token
+      #   @return [Regexp, String] used by split to separate token into pieces
+      attr_accessor :default_split_token
+      # when performing the split, use this regexp by default
+      DEFAULT_SPLIT_TOKEN = /-|_/
+      # @param [Regex,String] split_token defaults to DEFAULT_SPLIT_TOKEN=/-|_/
+      def initialize(default_split_token = DEFAULT_SPLIT_TOKEN)
+        @default_split_token = default_split_token
+      end
+
+      # @param [Array<#to_s>] faces
+      # @param [Regex,String] split_token defaults to default_split_token
+      # @return [Array<String>]
+      def resolve(faces, split_token = default_split_token)
+        faces.map { |f| f.to_s.split(split_token) }.flatten(1)
+      end
+    end
+  end
+end

data/lib/para_dice/string_die.rb

@@ -0,0 +1,15 @@
+require 'para_dice/die'
+require 'para_dice/faces/arrayed'
+
+module ParaDice
+  # A Simple die using an array of string faces
+  # @see ParaDice::Die and ParaDice::Faces::StringArrayed
+  class StringDie
+    include ParaDice::Die
+    include ParaDice::Faces::Arrayed
+
+    # @!attribute [rw] description
+    #   @return [String] defaults to a string like 'faces: foo, bar, baz'
+    attribute :description, String, default: ->(s, a) { 'faces: ' + s.faces.join(', ') }
+  end
+end

data/lib/para_dice/utility.rb

@@ -0,0 +1,54 @@
+require 'facets/string/modulize'
+require 'hashie'
+
+module ParaDice
+  module Utility
+    class IndifferentHash < Hash
+      include Hashie::Extensions::IndifferentAccess
+    end
+
+    # TODO ADD EXAMPLE
+    # @param [Class,Module,#to_s] name
+    # @param [Class, Module, #to_s] namespace
+    # @return [false] if no name is found at top level or namespace
+    # @return [Class,Module] the class or module represented by name
+    #   and optionally in namespace
+    def self.module_from(name, namespace = nil)
+      return name if name.is_a? Module
+      return false if name.empty?
+      self.module_from_top(name) || self.module_from_namespace(name, namespace)
+    end
+
+    # to_summary creates a hash and populates it with uniq elements of the
+    #   array, and the count of how many there are
+    # @param [Array] arr a list to summarize
+    # @return [Hash]
+    def self.to_summary(arr)
+      arr.reduce(Hash.new(0)) { |h, e| h[e] += 1; h }
+    end
+
+    # from_summary creates an array and populates with a number of each key
+    #   equal to the value for that key
+    # TODO ADD EXAMPLE
+    # @param [Hash<Object,Fixnum>] summary a hash to inflate a summary into an array
+    # @return [Array<Object>]
+    def self.from_summary(summary)
+      summary.each_pair.map { |e, c| Array.new(c) { e } }.flatten
+    end
+
+    private
+    def self.module_from_top(raw_name)
+      name = raw_name.to_s.modulize
+      return false if name.empty?
+      return false unless Kernel.const_defined?(name)
+      Kernel.const_get(name)
+    end
+
+    def self.module_from_namespace(raw_name, namespace)
+      return false unless namespace
+      name = raw_name.to_s.modulize
+      return false unless namespace.const_defined?(name)
+      namespace.const_get(name)
+    end
+  end
+end

data/lib/para_dice.rb

@@ -0,0 +1,9 @@
+require 'para_dice/die'
+# A Container Class for the key parts of the library: Bag, Die, Cup, Readers
+module ParaDice
+  # @param [Fixnum] max
+  # @ return [Die] die with sides 1..max
+  def self.numbered_die(max)
+    NumberedDie.get(max)
+  end
+end

data/lib/star_wars_dice.rb

@@ -0,0 +1,41 @@
+require 'para_dice/string_die'
+require 'para_dice/results/cancel_opposing'
+require 'para_dice/results/split_faces'
+require 'para_dice/results/hash'
+require 'para_dice/bag'
+require 'yaml'
+
+# A class for representing the game dice from Star Wars: Edge of the Empire,
+#   Star Wars: Age of Rebellion, Star Wars: Force and Destiny.  Mostly here as
+#   an example of how to create a custom dice bag.
+# @note no claim is made for the name StarWarsDice
+class StarWarsDice < ParaDice::Bag
+  # yaml file containing dice definitions
+  DATA_FILE_NAME  = 'data/star_wars_dice.yml'
+  # opposite facing to be used by the reader CancelOpposing
+  OPPOSING        = [
+      ['blank', 'blank'],
+      ['success', 'failure'],
+      ['advantage', 'threat']
+  ]
+  # The normal reader order for StarWarsDice.  First split the face names using
+  #   '_', then cancel opposing faces, finally return as a hash
+  DEFAULT_READERS = [
+      ParaDice::Results::SplitFaces.new('_'),
+      ParaDice::Results::CancelOpposing.new(OPPOSING),
+      ParaDice::Results::Hash
+  ]
+
+  # @!attribute [rw] dice
+  #   @return [Hash<String,StringDie>]
+  attribute :dice, Hash[String => ParaDice::StringDie]
+  # @!attribute [rw] default_readers
+  #   @return [Array<#resolve>]
+  attribute :default_readers, Array, default: ->(*a) { DEFAULT_READERS }
+
+  # load and return a bag of StarWarsDice
+  def self.get
+    hash = YAML.load_file(DATA_FILE_NAME)
+    self.new(name: 'Star Wars Dice', dice: hash)
+  end
+end

data/para_dice.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "para_dice"
+  spec.version       = File.read('VERSION')
+  spec.authors       = ["Scott M Parrish"]
+  spec.email         = ["anithri@gmail.com"]
+  spec.summary       = %q{Game Dev Toolbox.}
+  spec.description   = %q{A Toolbox to help me build a board game.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'virtus', '~> 1.0.3'
+  spec.add_runtime_dependency 'facets', '~> 2.9.3'
+  spec.add_runtime_dependency 'hashie', '~> 3.3.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.7.6'
+  spec.add_development_dependency 'yard', '~> 0.8.7.6'
+  spec.add_development_dependency 'rake', '~> 10.3.2'
+  spec.add_development_dependency 'rspec', '~> 3.1.0'
+  spec.add_development_dependency 'guard-rspec', '~> 4.3.1'
+  spec.add_development_dependency 'guard-bundler', '~> 2.0.0'
+  spec.add_development_dependency 'version', '~> 1.0.0'
+  spec.add_development_dependency 'fuubar', '~> 2.0.0'
+  
+end
+

data/spec/gotham_dice_spec.rb

@@ -0,0 +1,19 @@
+require 'rspec'
+require 'gotham_dice'
+
+describe GothamDice do
+  subject { described_class.get }
+  it { is_expected.to be_a described_class }
+  it { expect(subject.dice.keys.count).to eq 6 }
+  it { expect(subject.dice.values.all? { |d| d.is_a? ParaDice::StringDie }).to be true }
+  it { expect(subject.default_readers.size).to eq(3) }
+  it { expect(subject.default_readers[0]).to be_a ParaDice::Results::SplitFaces }
+  it { expect(subject.default_readers[1]).to be_a ParaDice::Results::CancelOpposing }
+  it { expect(subject.default_readers[2]).to eq ParaDice::Results::Hash }
+
+  describe '.get_cup' do
+    let(:dice) { ['combat', 'combat', 'detect', 'crime', 'move', 'move', 'crime', 'combat'] }
+    subject { described_class.get.get_cup(*dice) }
+    it { expect(subject.roll!.size).to eq 8 }
+  end
+end

data/spec/para_dice/bag_spec.rb

@@ -0,0 +1,53 @@
+require 'rspec'
+
+require 'para_dice/bag'
+require 'para_dice/numbered_die'
+require 'para_dice/results/number'
+describe ParaDice::Bag do
+  let(:d4) { ParaDice::NumberedDie.get(4) }
+  let(:d8) { ParaDice::NumberedDie.get(8) }
+  let(:d12) { ParaDice::NumberedDie.get(12) }
+  let(:bag) do
+    bag = described_class.new
+    bag.add_die d4
+    bag.add_die d12
+    bag.add_die d8
+    bag.default_readers << ParaDice::Results::Number.new
+    bag
+  end
+
+  context 'with all defaults' do
+    subject { described_class.new }
+    it do
+      is_expected.to have_attributes(name:            'Dice Bag',
+                                     dice:            {},
+                                     default_readers: [])
+    end
+  end
+
+  describe '.add_die(die)' do
+    let(:new_die) { ParaDice::NumberedDie.get(20) }
+    subject { described_class.new }
+    specify { expect(subject.dice).to be_empty }
+    it 'adds die to hash' do
+      subject.add_die(new_die)
+      expect(subject.dice['d20']).to eq new_die
+    end
+  end
+
+  describe 'get_dice(*dice_names)' do
+    let(:names) { ['d8', 'd8', 'd12'] }
+    subject { bag.get_dice(*names) }
+    it { expect(subject[0]).to eq d8 }
+    it { expect(subject[1]).to eq d8 }
+    it { expect(subject[2]).to eq d12 }
+  end
+
+  describe 'get_cup(*dice_names)' do
+    let(:names) { ['d8', 'd8', 'd12'] }
+    subject { bag.get_cup(*names) }
+    it { is_expected.to be_a ParaDice::Cup }
+    it { expect(subject.roll).to be_a Fixnum }
+    it { expect(subject.roll).to be_between 3, 28 }
+  end
+end

data/spec/para_dice/cup_spec.rb

@@ -0,0 +1,73 @@
+require 'rspec'
+
+require 'para_dice/cup'
+require 'para_dice/results/cancel_opposing'
+require 'para_dice/results/hash'
+
+describe ParaDice::Cup do
+
+  describe 'initialize' do
+    context 'with no arguments' do
+      subject { described_class.new }
+
+      it { is_expected.to have_attributes(dice: [], readers: [], rng: Random) }
+    end
+
+    context 'with rng seed' do
+      subject { described_class.new(rng: Random.new(111)) }
+      it { is_expected.to have_attributes(dice: [], readers: [], rng: Random) }
+
+      it { expect(subject.rng.seed).to eq 111 }
+    end
+  end
+
+  describe '.roll(roll_rng)' do
+    let(:fbb) { ParaDice::StringDie.new(name: 'FBB', faces: [:foo, :bar, :baz]) }
+
+    it 'call roll on all dice...' do
+      cup = described_class.new(dice: [fbb, fbb, fbb])
+      rng = double('rng')
+      allow(rng).to receive(:rand).and_return(2, 0, 2)
+      expect(rng).to receive(:rand).exactly(3).times
+      cup.roll(rng)
+    end
+
+    it '...return array' do
+      cup = described_class.new(dice: [fbb, fbb, fbb])
+      rng = double('rng')
+      allow(rng).to receive(:rand).and_return(2, 0, 2)
+      expect(cup.roll(rng)).to eq ['baz', 'foo', 'baz']
+    end
+  end
+
+  describe '.roll' do
+    let(:fbb) { ParaDice::StringDie.new(name: 'FBB', faces: [:foo, :bar, :baz]) }
+    let(:rng) do
+      rng = double('rng')
+      allow(rng).to receive(:rand).and_return(2, 0, 2, 1, 2)
+      rng
+    end
+    let(:dice_list) { [fbb, fbb, fbb, fbb, fbb] }
+    let(:cup) { described_class.new(dice: dice_list) }
+    context 'with no readers' do
+      subject { cup.roll(rng) }
+      it { is_expected.to eq ['baz', 'foo', 'baz', 'bar', 'baz'] }
+    end
+    context 'with a hash_reader' do
+      subject { cup.roll(rng) }
+      let(:readers) { [ParaDice::Results::Hash] }
+      let(:cup) { described_class.new(dice: dice_list, readers: readers)
+      it { is_expected.to eq('baz' => 3, 'foo' => 1, 'bar' => 1) } }
+    end
+    context 'with a cancel_opposing reader' do
+      subject { cup.roll(rng) }
+      let(:cancel_out) { [['foo', 'baz']] }
+      let(:readers) do
+        [ParaDice::Results::CancelOpposing.new(cancel_out),
+         ParaDice::Results::Hash]
+      end
+      let(:cup) { described_class.new(dice: dice_list, readers: readers) }
+      it { is_expected.to eq('baz' => 2, 'bar' => 1) }
+    end
+  end
+end

data/spec/para_dice/die_spec.rb

@@ -0,0 +1,21 @@
+require 'rspec'
+require 'para_dice/die'
+describe ParaDice::Die do
+  before(:all) do
+    class AbstractDie
+      include ParaDice::Die
+    end
+  end
+
+  let(:name) { 'fake_die' }
+  subject { AbstractDie.new(name: name) }
+  it { is_expected.to be_a ParaDice::Die }
+  it { is_expected.to have_attributes(name: 'fake_die', description: '') }
+  it { expect { subject.random_face }.to raise_error NotImplementedError, /random_face:/ }
+  it { expect { subject.faces }.to raise_error NotImplementedError, /faces:/ }
+  it { expect { subject.face_count }.to raise_error NotImplementedError, /face_count:/ }
+  it 'will raise an error if no id is given to initializer' do
+    expect { AbstractDie.new({}) }.to raise_error ArgumentError, /:name/
+  end
+
+end

data/spec/para_dice/faces/ranged_spec.rb

@@ -0,0 +1,42 @@
+require 'rspec'
+require 'para_dice/die'
+require 'para_dice/faces/ranged'
+
+describe ParaDice::Faces::Ranged do
+
+  before(:all) do
+    class RangedFaceDie
+      include ParaDice::Die
+      include ParaDice::Faces::Ranged
+    end
+  end
+
+  describe 'initialize' do
+    let(:name) { 'd10-19' }
+    let(:range) { 10..19 }
+    subject { RangedFaceDie.new(name: name, range: range) }
+    it { is_expected.to be_a ParaDice::Die }
+    it do
+      is_expected.to have_attributes(faces:      [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
+                                        name:       name,
+                                        range:      range,
+                                        face_count: 10)
+    end
+
+    it 'will call rand with size on rng' do
+      rng = double('random')
+      expect(rng).to receive(:rand).with(10).and_return(2)
+      subject.random_face(rng)
+    end
+
+    it 'will return the right value for a give rnd.rand result' do
+      rng = double('random')
+      allow(rng).to receive(:rand).with(10).and_return 4
+      expect(subject.random_face(rng)).to eq 14
+    end
+
+    it 'will raise an error if no range is given to initializer' do
+      expect { RangedFaceDie.new(name: 'oops').range }.to raise_error ArgumentError, /:range/
+    end
+  end
+end

data/spec/para_dice/faces/string_arrayed_spec.rb

@@ -0,0 +1,41 @@
+require 'rspec'
+
+require 'para_dice/faces/arrayed'
+
+describe ParaDice::Faces::Arrayed do
+
+  before(:all) do
+    class StringFaceDie
+      include ParaDice::Die
+      include ParaDice::Faces::Arrayed
+    end
+  end
+
+  describe 'initialize' do
+    let(:name) { 'FBB' }
+    let(:faces) { [:foo, :bar, :baz] }
+    subject { StringFaceDie.new(name: name, faces: faces) }
+    it { is_expected.to be_a ParaDice::Die }
+    it do
+      is_expected.to have_attributes(faces:      ['foo', 'bar', 'baz'],
+                                     name:       name,
+                                     face_count: 3)
+    end
+
+    it 'will call rand with size on rng' do
+      rng = double('random')
+      expect(rng).to receive(:rand).with(3).and_return(2)
+      subject.random_face(rng)
+    end
+
+    it 'will return the right value for a give rnd.rand result' do
+      rng = double('random')
+      allow(rng).to receive(:rand).with(3).and_return 1
+      expect(subject.random_face(rng)).to eq 'bar'
+    end
+
+    it 'will raise an error if no range is given to initializer' do
+      expect { StringFaceDie.new(name: 'oops') }.to raise_error ArgumentError, /:faces/
+    end
+  end
+end