acpc_poker_types 2.0.0 → 3.0.2

data/lib/acpc_poker_types/rank.rb

@@ -1,67 +1,69 @@
 
 require 'dmorrill10-utils'
 
-class AcpcPokerTypes::Rank
-  exceptions :unrecognized_rank
+module AcpcPokerTypes
+  class Rank
+    exceptions :unrecognized_rank
 
-  DOMAIN = {
-    two: {acpc_character: '2', text: '2', number: 0},
-    three: {acpc_character: '3', text: '3', number: 1},
-    four: {acpc_character: '4', text: '4', number: 2},
-    five: {acpc_character: '5', text: '5', number: 3},
-    six: {acpc_character: '6', text: '6', number: 4},
-    seven: {acpc_character: '7', text: '7', number: 5},
-    eight: {acpc_character: '8', text: '8', number: 6},
-    nine: {acpc_character: '9', text: '9', number: 7},
-    ten: {acpc_character: 'T', text: '10', number: 8},
-    jack: {acpc_character: 'J', text: 'J', number: 9},
-    queen: {acpc_character: 'Q', text: 'Q', number: 10},
-    king: {acpc_character: 'K', text: 'K', number: 11},
-    ace: {acpc_character: 'A', text: 'A', number: 12}
-  }
+    DOMAIN = {
+      two: {acpc_character: '2', text: '2', number: 0},
+      three: {acpc_character: '3', text: '3', number: 1},
+      four: {acpc_character: '4', text: '4', number: 2},
+      five: {acpc_character: '5', text: '5', number: 3},
+      six: {acpc_character: '6', text: '6', number: 4},
+      seven: {acpc_character: '7', text: '7', number: 5},
+      eight: {acpc_character: '8', text: '8', number: 6},
+      nine: {acpc_character: '9', text: '9', number: 7},
+      ten: {acpc_character: 'T', text: '10', number: 8},
+      jack: {acpc_character: 'J', text: 'J', number: 9},
+      queen: {acpc_character: 'Q', text: 'Q', number: 10},
+      king: {acpc_character: 'K', text: 'K', number: 11},
+      ace: {acpc_character: 'A', text: 'A', number: 12}
+    }
 
-  def self.hash_from_rank_token(rank)
-    if rank.kind_of?(Integer)
-      DOMAIN.find do |rank_symbol, properties|
-        properties[:number] == rank
-      end
-    else
-      DOMAIN.find do |rank_symbol, properties|
-        rank_symbol == rank.to_sym ||
+    def self.hash_from_rank_token(rank)
+      if rank.kind_of?(Integer)
+        DOMAIN.find do |rank_symbol, properties|
+          properties[:number] == rank
+        end
+      else
+        DOMAIN.find do |rank_symbol, properties|
+          rank_symbol == rank.to_sym ||
           properties[:acpc_character] == rank.to_s ||
           properties[:text] == rank.to_s
+        end
       end
     end
-  end
 
-  def self.symbol_from_rank_token(rank)
-    rank_hash = hash_from_rank_token rank
+    def self.symbol_from_rank_token(rank)
+      rank_hash = hash_from_rank_token rank
 
-    raise UnrecognizedRank, rank.to_s unless rank_hash
+      raise UnrecognizedRank, rank.to_s unless rank_hash
 
-    rank_hash.first
-  end
+      rank_hash.first
+    end
 
-  def initialize(rank)
-    @symbol = AcpcPokerTypes::Rank.symbol_from_rank_token rank
-  end
+    def initialize(rank)
+      @symbol = AcpcPokerTypes::Rank.symbol_from_rank_token rank
+    end
 
-  def to_sym
-    @symbol
-  end
+    def to_sym
+      @symbol
+    end
 
-  def to_i
-    DOMAIN[@symbol][:number]
-  end
+    def to_i
+      DOMAIN[@symbol][:number]
+    end
 
-  def to_acpc
-    DOMAIN[@symbol][:acpc_character]
-  end
+    def to_acpc
+      DOMAIN[@symbol][:acpc_character]
+    end
 
-  def to_s
-    DOMAIN[@symbol][:text]
-  end
+    def to_s
+      DOMAIN[@symbol][:text]
+    end
 
-  alias_method :to_html, :to_s
-  alias_method :to_str, :to_s
-end
+    alias_method :to_html, :to_s
+    alias_method :to_str, :to_s
+  end
+end

data/lib/acpc_poker_types/suit.rb

@@ -1,58 +1,60 @@
 
 require 'dmorrill10-utils'
 
-class AcpcPokerTypes::Suit
-  exceptions :unrecognized_suit
-
-  DOMAIN = {
-    clubs: {acpc_character: 'c', html_character: '♣', number: 0},
-    diamonds: {acpc_character: 'd', html_character: '♦', number: 1},
-    hearts: {acpc_character: 'h', html_character: '♥', number: 2},
-    spades: {acpc_character: 's', html_character: '♠', number: 3}
-  }
-
-  def self.hash_from_suit_token(suit)
-    if suit.kind_of?(Integer)
-      DOMAIN.find do |suit_symbol, properties|
-        properties[:number] == suit
-      end
-    else
-      DOMAIN.find do |suit_symbol, properties|
-        suit_symbol == suit.to_sym ||
-        properties[:acpc_character] == suit.to_s ||
-        properties[:html_character] == suit.to_s
+module AcpcPokerTypes
+  class Suit
+    exceptions :unrecognized_suit
+
+    DOMAIN = {
+      clubs: {acpc_character: 'c', html_character: '♣', number: 0},
+      diamonds: {acpc_character: 'd', html_character: '♦', number: 1},
+      hearts: {acpc_character: 'h', html_character: '♥', number: 2},
+      spades: {acpc_character: 's', html_character: '♠', number: 3}
+    }
+
+    def self.hash_from_suit_token(suit)
+      if suit.kind_of?(Integer)
+        DOMAIN.find do |suit_symbol, properties|
+          properties[:number] == suit
+        end
+      else
+        DOMAIN.find do |suit_symbol, properties|
+          suit_symbol == suit.to_sym ||
+          properties[:acpc_character] == suit.to_s ||
+          properties[:html_character] == suit.to_s
+        end
       end
     end
-  end
 
-  def self.symbol_from_suit_token(suit)
-    suit_hash = hash_from_suit_token suit
+    def self.symbol_from_suit_token(suit)
+      suit_hash = hash_from_suit_token suit
 
-    raise UnrecognizedSuit, suit.to_s unless suit_hash
+      raise UnrecognizedSuit, suit.to_s unless suit_hash
 
-    suit_hash.first
-  end
+      suit_hash.first
+    end
 
-  def initialize(suit)
-    @symbol = AcpcPokerTypes::Suit.symbol_from_suit_token suit
-  end
+    def initialize(suit)
+      @symbol = AcpcPokerTypes::Suit.symbol_from_suit_token suit
+    end
 
-  def to_sym
-    @symbol
-  end
+    def to_sym
+      @symbol
+    end
 
-  def to_i
-    DOMAIN[@symbol][:number]
-  end
+    def to_i
+      DOMAIN[@symbol][:number]
+    end
 
-  def to_acpc
-    DOMAIN[@symbol][:acpc_character]
-  end
+    def to_acpc
+      DOMAIN[@symbol][:acpc_character]
+    end
 
-  alias_method :to_s, :to_acpc
-  alias_method :to_str, :to_s
+    alias_method :to_s, :to_acpc
+    alias_method :to_str, :to_s
 
-  def to_html
-    DOMAIN[@symbol][:html_character]
+    def to_html
+      DOMAIN[@symbol][:html_character]
+    end
   end
-end
+end

data/lib/acpc_poker_types/version.rb

@@ -1,3 +1,3 @@
 module AcpcPokerTypes
-  VERSION = '2.0.0'
+  VERSION = '3.0.2'
 end

data/spec/card_spec.rb

@@ -6,11 +6,6 @@ require 'acpc_poker_types/card'
 
 describe AcpcPokerTypes::Card do
   describe '::from_acpc' do
-    it 'raises an exception if the given ACPC card string could not be parsed properly' do
-      -> do
-        AcpcPokerTypes::Card.from_acpc('not a card')
-      end.must_raise(AcpcPokerTypes::Card::ParseError)
-    end
     it 'works properly in all cases' do
       for_every_card! do
         @patient = AcpcPokerTypes::Card.from_acpc @acpc

data/spec/coverage/index.html

@@ -14,7 +14,7 @@
       <img src="./assets/0.7.1/loading.gif" alt="loading"/>
     </div>
     <div id="wrapper" style="display:none;">
-      <div class="timestamp">Generated <abbr class="timeago" title="2013-05-03T11:09:46-06:00">2013-05-03T11:09:46-06:00</abbr></div>
+      <div class="timestamp">Generated <abbr class="timeago" title="2013-05-05T16:00:29-07:00">2013-05-05T16:00:29-07:00</abbr></div>
       <ul class="group_tabs"></ul>
 
       <div id="content">

data/spec/match_state_spec.rb

@@ -37,10 +37,10 @@ describe AcpcPokerTypes::MatchState do
     it "parses every possible limit action" do
       partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":1:1:"
       hole_cards = arbitrary_hole_card_hand
-      AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.each do |action|
+      AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.each do |action|
         match_state = partial_match_state + action + ":" + hole_cards.to_acpc
         patient = test_match_state_success match_state
-        patient.last_action.to_acpc.must_equal action
+        patient.last_action.to_s.must_equal action
       end
     end
     it "parses every possible hole card hand" do
@@ -105,7 +105,7 @@ describe AcpcPokerTypes::MatchState do
     end
     it "parses a valid two player final match state" do
       partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":20:22:"
-      all_actions = AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join ''
+      all_actions = AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.to_a.join ''
       betting = all_actions
       number_of_rounds = 100
       (number_of_rounds-1).times do
@@ -120,7 +120,7 @@ describe AcpcPokerTypes::MatchState do
     end
     it "parses a valid three player final match state" do
       partial_match_state = AcpcPokerTypes::MatchState::LABEL + ":20:22:"
-      all_actions = AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.to_a.join ''
+      all_actions = AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.to_a.join ''
       betting = all_actions
       number_of_rounds = 100
       (number_of_rounds-1).times do
@@ -179,9 +179,9 @@ describe AcpcPokerTypes::MatchState do
       patient.first_state_of_first_round?.must_equal true
     end
     it 'works properly if a previous action exists' do
-      AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.each do |first_action|
-        AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.each do |second_action|
-          AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.each do |third_action|
+      AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.each do |first_action|
+        AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.each do |second_action|
+          AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.each do |third_action|
             partial_match_state = "#{AcpcPokerTypes::MatchState::LABEL}:1:1:"
 
             partial_match_state += first_action
@@ -228,14 +228,12 @@ def for_every_hand
     end
   end
 end
-
 def test_match_state_initialization_error(incomplete_match_state)
   ->{AcpcPokerTypes::MatchState.parse incomplete_match_state}.must_raise(AcpcPokerTypes::MatchState::IncompleteMatchState)
 end
 def test_match_state_success(match_state)
   patient = AcpcPokerTypes::MatchState.parse match_state
   patient.to_s.must_equal match_state
-
   patient
 end
 def arbitrary_flop
@@ -263,7 +261,7 @@ end
 
 # Construct an arbitrary hole card hand.
 #
-# @return [Mock AcpcPokerTypes::Hand] An arbitrary hole card hand.
+# @return [AcpcPokerTypes::Hand] An arbitrary hole card hand.
 def arbitrary_hole_card_hand
   AcpcPokerTypes::Hand.from_acpc(
     AcpcPokerTypes::Rank::DOMAIN[:two][:acpc_character] +

data/spec/player_spec.rb

@@ -119,7 +119,7 @@ describe AcpcPokerTypes::Player do
   end
   describe 'reports it is not active if' do
     it 'it has folded' do
-      action = AcpcPokerTypes::PokerAction.new :fold, {amount_to_put_in_pot: 0}
+      action = AcpcPokerTypes::PokerAction.new AcpcPokerTypes::PokerAction::FOLD
 
       @patient.start_new_hand! BLIND, INITIAL_CHIP_STACK
       @patient.take_action! action
@@ -137,7 +137,7 @@ describe AcpcPokerTypes::Player do
       check_patient
     end
     it 'it is all-in' do
-      action = AcpcPokerTypes::PokerAction.new :raise, {amount_to_put_in_pot: INITIAL_CHIP_STACK - BLIND}
+      action = AcpcPokerTypes::PokerAction.new AcpcPokerTypes::PokerAction::RAISE, cost: INITIAL_CHIP_STACK - BLIND
 
       hand = default_hand
       @patient.start_new_hand! BLIND, INITIAL_CHIP_STACK, hand
@@ -186,7 +186,7 @@ describe AcpcPokerTypes::Player do
         "#{dealer_log_directory}/#{log_description.results_file_name}",
         log_description.player_names,
         AcpcDealer::DEALER_DIRECTORY,
-        40
+        120
       )
       match.for_every_seat! do |seat|
         @patient = AcpcPokerTypes::Player.join_match(
@@ -325,24 +325,17 @@ end
       yield modifier
     end
   end
-  def instantiate_each_action_from_symbols(amount_to_put_in_pot=0,
-                                           modifier=nil)
-    AcpcPokerTypes::PokerAction::LEGAL_SYMBOLS.each do |sym|
-      modifier = if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.keys.include? sym
+  def instantiate_each_action_from_symbols(
+    cost=0, modifier=nil
+  )
+    AcpcPokerTypes::PokerAction::CANONICAL_ACTIONS.each do |action|
+      modifier = if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.include? action
         modifier
       else
         nil
       end
 
-      action = mock 'AcpcPokerTypes::PokerAction'
-      action.stubs(:to_sym).returns(sym)
-      action.stubs(:to_s).returns(sym.to_s + modifier.to_s)
-      action.stubs(:to_acpc).returns(AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[sym] + modifier.to_s)
-      action.stubs(:to_acpc_character).returns(AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[sym])
-      action.stubs(:amount_to_put_in_pot).returns(amount_to_put_in_pot)
-      action.stubs(:modifier).returns(modifier)
-
-      yield action
+      yield AcpcPokerTypes::PokerAction.new(action, cost: cost, modifier: modifier)
     end
   end
   def test_sequence_of_non_fold_actions(hole_cards=default_hand)
@@ -364,10 +357,10 @@ end
       end
 
       various_actions do |action|
-        next if :fold == action.to_sym
+        next if AcpcPokerTypes::PokerAction::FOLD == action.to_s
 
-        chip_stack_adjustment = if @chip_stack - action.amount_to_put_in_pot >= 0
-          action.amount_to_put_in_pot
+        chip_stack_adjustment = if @chip_stack - action.cost >= 0
+          action.cost
         else @chip_stack end
 
         @chip_balance -= chip_stack_adjustment

data/spec/poker_action_spec.rb

@@ -5,202 +5,136 @@ require_relative 'support/spec_helper'
 require 'acpc_poker_types/poker_action'
 
 describe AcpcPokerTypes::PokerAction do
-  describe 'legal actions can be retrieved' do
-    it 'with ::LEGAL_ACTIONS' do
-      AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.wont_be_empty
-    end
-
-    it 'in symbol format' do
-      AcpcPokerTypes::PokerAction::LEGAL_SYMBOLS.wont_be_empty
-    end
-
-    it 'in string format' do
-      AcpcPokerTypes::PokerAction::LEGAL_STRINGS.wont_be_empty
-    end
+  DEFAULT_MODIFIER = '9001'
+  DEFAULT_COST = 9002
 
-    it 'in acpc format' do
-      AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.wont_be_empty
+  describe 'legal actions can be retrieved' do
+    it 'with ::legal_actions' do
+      AcpcPokerTypes::PokerAction::ACTIONS.wont_be_empty
     end
   end
-
   describe '#new' do
     it 'raises an exception if the given action is invalid' do
-      ->{AcpcPokerTypes::PokerAction.new(:not_an_action)}.must_raise(AcpcPokerTypes::PokerAction::IllegalAction)
+      ->{AcpcPokerTypes::PokerAction.new('not_an_action')}.must_raise(AcpcPokerTypes::PokerAction::IllegalAction)
     end
     it 'raises an exception if a modifier accompanies an unmodifiable action' do
-      unmodifiable_actions = AcpcPokerTypes::PokerAction::LEGAL_SYMBOLS - AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.keys
-      unmodifiable_actions.each do |sym|
-        ->{AcpcPokerTypes::PokerAction.new(sym, {modifier: default_modifier})}.must_raise(AcpcPokerTypes::PokerAction::IllegalAmount)
+      unmodifiable_actions = AcpcPokerTypes::PokerAction::ACTIONS - AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS
+      unmodifiable_actions.each do |a|
+        ->{AcpcPokerTypes::PokerAction.new(a, modifier: DEFAULT_MODIFIER)}.must_raise(AcpcPokerTypes::PokerAction::IllegalModification)
       end
     end
     it 'raise an exception if a modifier is given both implicitly and explicitly' do
-      ->{AcpcPokerTypes::PokerAction.new('r9001', {modifier: default_modifier})}.must_raise(AcpcPokerTypes::PokerAction::IllegalAmount)
-    end
-    it 'raise an exception if a fold action is given when no wager is seen by the acting player' do
-      ->{AcpcPokerTypes::PokerAction.new('f', {acting_player_sees_wager: false})}.must_raise(AcpcPokerTypes::PokerAction::IllegalAction)
+      ->{AcpcPokerTypes::PokerAction.new('r9001', modifier: DEFAULT_MODIFIER)}.must_raise(AcpcPokerTypes::PokerAction::IllegalModification)
     end
     describe 'creates actions properly' do
-      it 'from various forms' do
-        various_amounts_to_put_in_pot do |amount|
-          with_and_without_a_modifier do |modifier|
-            instantiate_each_action_from_acpc_characters(amount, modifier) do |char, actual_modifier|
-              check_patient_data AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.key(char),
-                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.key(char).to_s + actual_modifier.to_s,
-                char + actual_modifier.to_s,
-                char,
-                amount,
-                actual_modifier
-            end
-            instantiate_each_action_from_strings(amount, modifier) do |string, actual_modifier|
-              check_patient_data string.to_sym,
-                string + actual_modifier.to_s,
-                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[string.to_sym] + actual_modifier.to_s,
-                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[string.to_sym],
-                amount,
-                actual_modifier
-            end
-            instantiate_each_action_from_symbols(amount, modifier) do |sym, actual_modifier|
-              check_patient_data sym,
-                sym.to_s + actual_modifier.to_s,
-                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[sym] + actual_modifier.to_s,
-                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[sym],
-                amount,
-                actual_modifier
-            end
-            instantiate_each_action_from_modified_acpc_characters(amount, modifier) do |char, actual_modifier|
-              check_patient_data AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.key(char),
-                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.key(char).to_s + actual_modifier.to_s,
-                char + actual_modifier.to_s,
-                char,
-                amount,
-                actual_modifier
-            end
-            instantiate_each_action_from_modified_strings(amount, modifier) do |string, actual_modifier|
-              check_patient_data string.to_sym,
-                string + actual_modifier.to_s,
-                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[string.to_sym] + actual_modifier.to_s,
-                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[string.to_sym],
-                amount,
-                actual_modifier
-            end
+      it 'without modifiers' do
+        AcpcPokerTypes::PokerAction::ACTIONS.each do |a|
+          AcpcPokerTypes::PokerAction.new(a)
+        end
+      end
+      it 'with an explicit modifier' do
+        AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.each do |a|
+          AcpcPokerTypes::PokerAction.new(a, modifier: DEFAULT_MODIFIER)
+        end
+      end
+      it 'with an implicit modifier' do
+        AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.each do |a|
+          AcpcPokerTypes::PokerAction.new(a + DEFAULT_MODIFIER)
+        end
+      end
+      describe 'with explicit cost' do
+        it 'when the cost is positive' do
+          AcpcPokerTypes::PokerAction::ACTIONS.each do |a|
+            AcpcPokerTypes::PokerAction.new(a, cost: DEFAULT_COST).cost.must_equal DEFAULT_COST
+          end
+        end
+        it 'when the cost is negative' do
+          AcpcPokerTypes::PokerAction::ACTIONS.each do |a|
+            AcpcPokerTypes::PokerAction.new(a, cost: -DEFAULT_COST).cost.must_equal -DEFAULT_COST
           end
         end
       end
     end
-  end
-  describe 'given knowledge that the acting player does not see a wager' do
-    it 'properly changes the given action to its more precise form' do
-      AcpcPokerTypes::PokerAction::HIGH_RESOLUTION_ACTION_CONVERSION.each do |imprecise_action, precise_action|
-        next if :fold == imprecise_action
-        imprecise_action_character = AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[imprecise_action]
-        precise_action_character = AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[precise_action]
-        if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.values.include? imprecise_action_character
-          modifier = default_modifier
-          expected_acpc_form = precise_action_character + modifier.to_s
-        else
-          modifier = nil
-          expected_acpc_form = precise_action_character
+    it 'performs reasonably well' do
+      1000.times do
+        AcpcPokerTypes::PokerAction::ACTIONS.each do |a|
+          AcpcPokerTypes::PokerAction.new(a)
         end
-        AcpcPokerTypes::PokerAction.new(imprecise_action_character, {modifier: modifier, acting_player_sees_wager: false}).to_acpc.must_equal(expected_acpc_form)
       end
     end
   end
-
-  def default_modifier
-    modifier_amount = 9001
-    modifier = mock 'AcpcPokerTypes::ChipStack'
-    modifier.stubs(:to_s).returns(modifier_amount.to_s)
-    modifier
-  end
-  def various_amounts_to_put_in_pot
-    [0, 9002, -9002].each do |amount|
-      yield amount
-    end
-  end
-  def with_and_without_a_modifier
-    [nil, default_modifier].each do |modifier|
-      yield modifier
-    end
-  end
-  def check_patient_data(expected_sym,
-                         expected_string,
-                         expected_acpc,
-                         expected_acpc_character,
-                         amount_to_put_in_pot=0,
-                         modifier=nil)
-    @patient.to_sym.must_equal expected_sym
-    @patient.to_s.must_equal expected_string
-    @patient.to_acpc.must_equal expected_acpc
-    @patient.to_acpc_character.must_equal expected_acpc_character
-    @patient.amount_to_put_in_pot.must_equal amount_to_put_in_pot
-
-    has_modifier = !modifier.nil?
-    @patient.has_modifier?.must_equal has_modifier
-  end
-  def instantiate_each_action_from_symbols(amount_to_put_in_pot=0,
-                                           modifier=nil)
-    AcpcPokerTypes::PokerAction::LEGAL_SYMBOLS.each do |sym|
-      modifier = if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.keys.include? sym
-        modifier
-      else
-        nil
+  describe '#to_s' do
+    it "prints in the dealer's canonical representation by default" do
+      AcpcPokerTypes::PokerAction::ACTIONS.each do |a|
+        AcpcPokerTypes::PokerAction.new(a).to_s.must_equal (
+          case a
+          when AcpcPokerTypes::PokerAction::BET
+            AcpcPokerTypes::PokerAction::RAISE
+          when AcpcPokerTypes::PokerAction::CALL
+            AcpcPokerTypes::PokerAction::CALL
+          when AcpcPokerTypes::PokerAction::CHECK
+            AcpcPokerTypes::PokerAction::CALL
+          when AcpcPokerTypes::PokerAction::FOLD
+            AcpcPokerTypes::PokerAction::FOLD
+          when AcpcPokerTypes::PokerAction::RAISE
+            AcpcPokerTypes::PokerAction::RAISE
+          end
+        )
       end
-
-      @patient = AcpcPokerTypes::PokerAction.new(sym, {amount_to_put_in_pot: amount_to_put_in_pot, modifier: modifier})
-      yield sym, modifier
     end
-  end
-  def instantiate_each_action_from_strings(amount_to_put_in_pot=0,
-                                           modifier=nil)
-    AcpcPokerTypes::PokerAction::LEGAL_STRINGS.each do |string|
-      modifier = if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.keys.include? string.to_sym
-        modifier
-      else
-        nil
+    it 'works properly when no chips have been added to the pot' do
+      AcpcPokerTypes::PokerAction::ACTIONS.each do |a|
+        AcpcPokerTypes::PokerAction.new(a).to_s(pot_gained_chips: false).must_equal (
+          case a
+          when AcpcPokerTypes::PokerAction::BET
+            AcpcPokerTypes::PokerAction::BET
+          when AcpcPokerTypes::PokerAction::CALL
+            AcpcPokerTypes::PokerAction::CHECK
+          when AcpcPokerTypes::PokerAction::CHECK
+            AcpcPokerTypes::PokerAction::CHECK
+          when AcpcPokerTypes::PokerAction::FOLD
+            AcpcPokerTypes::PokerAction::FOLD
+          when AcpcPokerTypes::PokerAction::RAISE
+            AcpcPokerTypes::PokerAction::BET
+          end
+        )
       end
-
-      @patient = AcpcPokerTypes::PokerAction.new(string, {amount_to_put_in_pot: amount_to_put_in_pot, modifier: modifier})
-      yield string, modifier
-    end
-  end
-  def instantiate_each_action_from_modified_strings(amount_to_put_in_pot=0,
-                                                    modifier=nil)
-    unless modifier
-      modifier = mock('AcpcPokerTypes::ChipStack')
-      modifier.stubs(:to_s).returns('9001')
     end
-    AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.values.each do |char|
-      string = AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.key(char).to_s
-      modified_action = string + modifier.to_s
-
-      @patient = AcpcPokerTypes::PokerAction.new(modified_action, {amount_to_put_in_pot: amount_to_put_in_pot})
-      yield string, modifier
-    end
-  end
-  def instantiate_each_action_from_acpc_characters(amount_to_put_in_pot=0,
-                                                   modifier=nil)
-    AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.each do |char|
-      modifier = if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.values.include? char
-        modifier
-      else
-        nil
+    it 'works properly when the player is not facing a wager' do
+      AcpcPokerTypes::PokerAction::ACTIONS.each do |a|
+        AcpcPokerTypes::PokerAction.new(a).to_s(player_sees_wager: false).must_equal (
+          case a
+          when AcpcPokerTypes::PokerAction::BET
+            AcpcPokerTypes::PokerAction::RAISE
+          when AcpcPokerTypes::PokerAction::CALL
+            AcpcPokerTypes::PokerAction::CHECK
+          when AcpcPokerTypes::PokerAction::CHECK
+            AcpcPokerTypes::PokerAction::CHECK
+          when AcpcPokerTypes::PokerAction::FOLD
+            AcpcPokerTypes::PokerAction::FOLD
+          when AcpcPokerTypes::PokerAction::RAISE
+            AcpcPokerTypes::PokerAction::RAISE
+          end
+        )
       end
-
-      @patient = AcpcPokerTypes::PokerAction.new(char, {amount_to_put_in_pot: amount_to_put_in_pot, modifier: modifier})
-      yield char, modifier
     end
-  end
-  def instantiate_each_action_from_modified_acpc_characters(amount_to_put_in_pot=0,
-                                                            modifier=nil)
-    unless modifier
-      modifier = mock('AcpcPokerTypes::ChipStack')
-      modifier.stubs(:to_s).returns('9001')
-    end
-    AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.values.each do |char|
-      modified_action = char + modifier.to_s
-
-      @patient = AcpcPokerTypes::PokerAction.new(modified_action, {amount_to_put_in_pot: amount_to_put_in_pot})
-      yield char, modifier
+    it 'works properly when the player is not facing a wager, nor have chips been added to the pot' do
+      AcpcPokerTypes::PokerAction::ACTIONS.each do |a|
+        AcpcPokerTypes::PokerAction.new(a).to_s(player_sees_wager: false, pot_gained_chips: false).must_equal (
+          case a
+          when AcpcPokerTypes::PokerAction::BET
+            AcpcPokerTypes::PokerAction::BET
+          when AcpcPokerTypes::PokerAction::CALL
+            AcpcPokerTypes::PokerAction::CHECK
+          when AcpcPokerTypes::PokerAction::CHECK
+            AcpcPokerTypes::PokerAction::CHECK
+          when AcpcPokerTypes::PokerAction::FOLD
+            AcpcPokerTypes::PokerAction::FOLD
+          when AcpcPokerTypes::PokerAction::RAISE
+            AcpcPokerTypes::PokerAction::BET
+          end
+        )
+      end
     end
   end
-end
+end