ruby_holdem 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29fbffb1efbe129bc60cc9b38ef8f048c2e18ab9
-  data.tar.gz: 0b99f0a5ebf3996ae2fe11b169647cf1dd74384b
+  metadata.gz: 1dd48e6184eca19ac256511789c5effc59d11afb
+  data.tar.gz: 2a199bdde72d3903b13453f8743889fa83a5b0f7
 SHA512:
-  metadata.gz: c4b072056f11a740fe63f29deceb02a692114c152b6532ccb83364757b83728f7cb4425f063f8baeee3373672a31eaf6944a748b42dc9ee35a3c155b8b4bd172
-  data.tar.gz: 409610a9e35b4ec60cfb4730edea0ca4d7958f53682e20b039a502d2d2e3264f89c4d8e26327f577f023324facf3112340c77b4fa922d4bc046068cb76036e8e
+  metadata.gz: 77f78e0b36c92cd26b9dda7ef221044b6ad18bef2d0798870633d31a5617dc2136d4e5943cf829c78de1b0a97b7ee157b7da1ab277b4788b36902576c4f5c4f7
+  data.tar.gz: e3d0e79ae799214fbafbe318abdb276d3d95c247ebffd6efdc7093ca8f7a9d40d28014a92b37f02e913dd4b8ea8463436e852dc2f63137ec06670a33f02307b6

data/README.md

@@ -3,8 +3,6 @@ RubyHoldem is a set of classes which track the game state of a texas holdem poke
 
 ### Installation
 ```
-git clone git@github.com:evanrolfe/ruby-holdem.git
-cd ruby-holdem/
 gem install ruby_holdem
 ```
 
@@ -15,11 +13,11 @@ require 'ruby_holdem'
 players = ["Jack", "Joe", "Jil"]
 poker_round = RubyHoldem::Round.new(players, 2, 4)
 
-poker_round.make_move('bet', 2) # Jack bets small blinds
-poker_round.make_move('bet', 4) # Joe bets big blinds
+poker_round.make_move('raise', 2) # Jack raises small blinds
+poker_round.make_move('raise', 4) # Joe raises big blinds
 poker_round.make_move('fold') # Jil folds
 poker_round.make_move('call') # Jack calls
-poker_round.make_move('call') # Joe calls
+poker_round.make_move('check') # Joe calls
 poker_round.next_stage
 
 puts poker_round.community_cards.join(' ')
@@ -28,13 +26,19 @@ puts poker_round.community_cards.join(' ')
 puts poker_round.pot_amount
 # => 8
 
-poker_round.make_move('bet', 3) # Jack bets 3
+poker_round.make_move('raise', 3) # Jack raises 3
 poker_round.make_move('fold') # Joe folds
 
 puts poker_round.winner
 # => Jack
 ```
 
+### TODO
+- Break monolithic ```Round``` class into smaller classes, i.e. ```Round```, ```RoundState``` and ```RoundPlayerMove```
+- Use rspec 3 style (subjects, expects etc.)
+- Get rid of the stubbing of action_history instance var in round_spec.rb
+- Have ```Game``` keep track of an entire poker game consisting of multiple rounds
+
 ### License
 
 RubyHoldem uses the MIT license. Please check the [LICENSE](https://github.com/evanrolfe/ruby-holdem/blob/master/LICENSE) file for more details.

data/lib/ruby_holdem.rb

@@ -4,4 +4,10 @@ require 'ruby_holdem/errors'
 
 require 'ruby_holdem/dealer'
 require 'ruby_holdem/round'
-require 'ruby_holdem/round_player'
+require 'ruby_holdem/round/move_factory'
+require 'ruby_holdem/round/move_history'
+require 'ruby_holdem/round/move_history_computations'
+require 'ruby_holdem/round/move_validator'
+require 'ruby_holdem/round/player'
+
+require 'pry'

data/lib/ruby_holdem/errors.rb

@@ -1,7 +1,7 @@
 module RubyHoldem
-  class MinBetNotMeet < StandardError
+  class MinRaiseNotMeet < StandardError
   end
 
-  class NotEnoughMoney < StandardError
+  class InsufficientFunds < StandardError
   end
 end

data/lib/ruby_holdem/round.rb

@@ -4,151 +4,57 @@ module RubyHoldem
   class Round
     extend Forwardable
 
-    attr_reader :players,
-                :small_blinds,
+    attr_reader :small_blinds,
                 :big_blinds,
                 :pot_amount,
-                :current_stage,
-                :action_history,
-                :dealer,
-                :turns_played
+                :players,
+                :state
 
     def_delegator :@dealer, :community_cards
 
+    def_delegators :@move_history_computations, :ready_for_next_stage?,
+                                                :has_winner?,
+                                                :winner,
+                                                :player_in_turn,
+                                                :players_still_in_round,
+                                                :highest_bet_placed
+
+    def_delegators :@move_history, :stage,
+                                   :last_move,
+                                   :turns_played,
+                                   :moves
+
     STAGES = %w(pre_flop flop turn river show_down)
 
     def initialize(players, small_blinds, big_blinds)
-      @small_blinds, @big_blinds = small_blinds, big_blinds
-      @current_stage = STAGES[0]
+      @small_blinds = small_blinds
+      @big_blinds = big_blinds
       @pot_amount = 0
-      @action_history = []
 
-      @players = players.map { |player| RoundPlayer.new(player) }
+      @players = players.map { |player| Player.new(player) }
+      @move_history = MoveHistory.new
+      @move_history_computations = MoveHistoryComputations.new(@players, @move_history)
+
       @dealer = Dealer.new
       @dealer.deal_hole_cards(@players)
     end
 
-    # TODO: Extract the code relating to making a move into its own class to separate the logic
-    #       behind making a move and the game state methods
-    def make_move(move, amount=nil)
-      if turns_played == 0
-        apply_bet(small_blinds)
-      elsif turns_played == 1
-        apply_bet(big_blinds)
-      elsif move == 'bet'
-        apply_bet(amount)
-      elsif move == 'call'
-        apply_call
-      elsif move == 'fold'
-        apply_fold
-      end
-    end
-
-    def next_stage
-      raise StandardError unless ready_for_next_stage? && @current_stage != 'show_down'
-
-      @current_stage = STAGES[STAGES.index(@current_stage)+1]
-      @dealer.deal_community_cards(@current_stage)
-    end
-
-    def ready_for_next_stage?
-      return false unless every_player_has_called? && turns_played_in_stage > 0
-
-      players_still_in_round.map { |player| (player.current_bet_amount == highest_bet_placed) }.all?
-    end
-
-    def has_winner?
-      (current_stage == 'show_down' || players_still_in_round.count == 1)
-    end
-
-    def winner
-      return players_still_in_round[0] if players_still_in_round.count == 1
-      return players_still_in_round[2]
-    end
-
-    # TODO: Refactor this method to make it more readable
-    def player_in_turn  #The player whose turn it is to make a move
-      return players[0] if action_history.length == 0
-
-      last_player_index = players.index(action_history.last[:player])
-      player_found = false
-      increment=1
-
-      until player_found
-        next_player = players[(last_player_index + increment) % players.length]   #Wrap around the array once end reached
-        player_found = true if players_still_in_round.include?(next_player)
-        increment += 1
-      end
-
-      next_player
-    end
-
-    def players_still_in_round
-      players.select do |round_player|
-        folds = action_history.select { |action| action[:move] == 'fold' && action[:player] == round_player }
-        (folds.length == 0)
-      end
-    end
-
-    def highest_bet_placed
-      players_still_in_round.max_by(&:current_bet_amount).current_bet_amount
-    end
-
-    def last_move
-      action_history.last
-    end
+    def make_move(move_type, amount=nil)
+      move = MoveFactory.new(self, player_in_turn, move_type, amount).build
 
-    private
+      MoveValidator.new(self, move).validate
 
-    def turns_played
-      action_history.length
-    end
-
-    def turns_played_in_stage
-      action_history.select { |action| action[:stage] == @current_stage }.length
-    end
-
-    def every_player_has_called?
-      players_num_calls = players_still_in_round.map do |round_player|
-        calls = action_history.select { |action| action[:stage] == @current_stage && action[:move] == 'call' && action[:player] == round_player }
-        calls.length
+      unless move[:amount].nil?
+        player_in_turn.current_bet_amount += move[:amount]
+        @pot_amount += move[:amount]
       end
 
-      players_num_calls.map { |num_calls| num_calls >= 1 }.all?
+      @move_history.add_move(move)
     end
 
-    def apply_bet(amount)
-      raise MinBetNotMeet if amount < min_bet_amount_for_player(player_in_turn)
-
-      #TODO: Go all in instead of raising an error
-      raise NotEnoughMoney unless player_can_afford_bet?(player_in_turn, amount)
-
-      @pot_amount += amount
-      player_in_turn.current_bet_amount += amount
-      action_history << { player: player_in_turn, stage: current_stage, move: 'bet', amount: amount}
-    end
-
-    def apply_call
-      amount = min_bet_amount_for_player(player_in_turn)
-      raise NotEnoughMoney unless player_can_afford_bet?(player_in_turn, amount)
-
-      @pot_amount += amount
-      player_in_turn.current_bet_amount += amount
-
-      action_history << { player: player_in_turn, stage: current_stage, move: 'call', amount: amount}
-    end
-
-    def apply_fold
-      action_history << { player: player_in_turn, stage: current_stage, move: 'fold', amount: 0}
-    end
-
-    def min_bet_amount_for_player(player)
-      highest_bet_placed - player.current_bet_amount
-    end
-
-    # TODO:
-    def player_can_afford_bet?(player, bet_amount)
-      true
+    def next_stage
+      @move_history.next_stage
+      @dealer.deal_community_cards(@move_history.stage)
     end
   end
 end

data/lib/ruby_holdem/round/move_factory.rb

@@ -0,0 +1,51 @@
+module RubyHoldem
+  class Round
+    class MoveFactory
+      attr_reader :round, :player, :move_type, :amount
+
+      def initialize(round, player, move_type, amount)
+        @round = round
+        @player = player
+        @move_type = move_type
+        @amount = amount
+      end
+
+      def build
+        {
+          player: player,
+          stage: stage,
+          move_type: move_type,
+          amount: actual_amount
+        }
+      end
+
+      private
+
+      def actual_amount
+        if move_type == "call"
+          highest_bet_placed - current_bet_amount
+        else
+          amount
+        end
+      end
+
+      #
+      # Dependencies on Round class
+      #
+      def stage
+        round.stage
+      end
+
+      def highest_bet_placed
+        @highest_bet_placed ||= round.highest_bet_placed
+      end
+
+      #
+      # Dependencies on Player class
+      #
+      def current_bet_amount
+        @current_bet_amount ||= player.current_bet_amount
+      end
+    end
+  end
+end

data/lib/ruby_holdem/round/move_history.rb

@@ -0,0 +1,28 @@
+module RubyHoldem
+  class Round
+    class MoveHistory
+      attr_reader :moves, :stage
+
+      def initialize
+        @moves = []
+        @stage = STAGES.first
+      end
+
+      def add_move(move)
+        moves << move
+      end
+
+      def last_move
+        moves.last
+      end
+
+      def turns_played
+        moves.count
+      end
+
+      def next_stage
+        @stage = STAGES[STAGES.index(stage)+1]
+      end
+    end
+  end
+end

data/lib/ruby_holdem/round/move_history_computations.rb

@@ -0,0 +1,105 @@
+module RubyHoldem
+  class Round
+    class MoveHistoryComputations
+      attr_reader :players, :move_history
+
+      def initialize(players, move_history)
+        @players = players
+        @move_history = move_history
+      end
+
+      def highest_bet_placed
+        get_current_bet_amount_for_player(
+          players_still_in_round.max_by(&:current_bet_amount)
+        )
+      end
+
+      def ready_for_next_stage?
+        every_player_has_checked? && turns_played_in_stage > 0
+      end
+
+      def has_winner?
+        (stage == 'show_down' || players_still_in_round.count == 1)
+      end
+
+      # TODO: Compare the hands of the two players
+      def winner
+        return players_still_in_round[0] if players_still_in_round.count == 1
+      end
+
+      def turns_played_in_stage
+        moves.select { |move| move[:stage] == stage }.length
+      end
+
+      def player_in_turn  #The player whose turn it is to make a move
+        return players[0] if moves.length == 0
+
+        last_player = moves.last[:player]
+        i = (players.index(last_player) + 1) % players.length
+
+        player_found = false
+        until player_found
+          at_end_of_array = (i == (players.length - 1))
+
+          if player_is_folded?(players[i]) && !at_end_of_array
+            i += 1
+          elsif player_is_folded?(players[i]) && at_end_of_array
+            i = 0
+          else
+            player_found = true
+          end
+        end
+        players[i]
+      end
+
+      def every_player_has_checked?
+        players_num_checks = players_still_in_round.map do |round_player|
+          checks = moves.select do |move|
+            move[:stage] == stage &&
+              move[:move_type] == 'check' &&
+              move[:player] == round_player
+          end
+          checks.length
+        end
+
+        players_num_checks.map { |num_checks| num_checks >= 1 }.all?
+      end
+
+      def players_still_in_round
+        players.select do |round_player|
+          folds = moves.select do |move|
+            move[:move_type] == 'fold' && move[:player] == round_player
+          end
+
+          folds.length == 0
+        end
+      end
+
+      private
+
+      def player_is_folded?(player)
+        moves.select do |move|
+          move[:move_type] == 'fold' && move[:player] == player
+        end.any?
+      end
+
+      #
+      # Dependencies on MoveHistory class
+      #
+      def moves
+        move_history.moves
+      end
+
+      def stage
+        move_history.stage
+      end
+
+      #
+      # Dependencies on Player class
+      #
+      def get_current_bet_amount_for_player(player)
+        player.current_bet_amount
+      end
+    end
+  end
+end

data/lib/ruby_holdem/round/move_validator.rb

@@ -0,0 +1,110 @@
+module RubyHoldem
+  class Round
+    class MoveValidator
+      attr_reader :round, :move
+
+      def initialize(round, move)
+        @round = round
+        @move = move
+      end
+
+      def validate
+        if blinds_turn? && blinds_not_met?
+          raise MinRaiseNotMeet, "You must bet blinds."
+        end
+
+        send("validate_#{move_type}")
+      end
+
+      private
+
+      def validate_raise
+        if amount < min_raise_amount
+          raise MinRaiseNotMeet
+        end
+
+        if !player_can_afford_raise?
+          raise InsufficientFunds
+        end
+      end
+
+      def validate_call
+        if !player_can_afford_raise?
+          raise InsufficientFunds
+        end
+      end
+
+      def validate_check
+        if min_raise_amount > 0
+          raise MinRaiseNotMeet
+        end
+      end
+
+      def validate_fold
+        true # NOTE: You can always fold as long as its not a blinds turn
+      end
+
+      def min_raise_amount
+        @min_raise_amount ||= highest_bet_placed - current_bet_amount
+      end
+
+      # TODO:
+      def player_can_afford_raise?
+        true
+      end
+
+      def blinds_turn?
+        turns_played == 0 || turns_played == 1
+      end
+
+      def blinds_not_met?
+        if turns_played == 0
+          amount < small_blinds
+        elsif turns_played == 1
+          amount < big_blinds
+        end
+      end
+
+      #
+      # Dependencies on Round class
+      #
+      def highest_bet_placed
+        @highest_bet_placed ||= round.highest_bet_placed
+      end
+
+      def turns_played
+        @turns_played ||= round.turns_played
+      end
+
+      def small_blinds
+        @small_blinds ||= round.small_blinds
+      end
+
+      def big_blinds
+        @big_blinds ||= round.big_blinds
+      end
+
+      #
+      # Dependencies on Player class
+      #
+      def current_bet_amount
+        @current_bet_amount ||= player.current_bet_amount
+      end
+
+      #
+      # Dependencies on MoveFactory
+      #
+      def amount
+        move[:amount]
+      end
+
+      def move_type
+        move[:move_type]
+      end
+
+      def player
+        move[:player]
+      end
+    end
+  end
+end

data/lib/ruby_holdem/round/player.rb

@@ -0,0 +1,13 @@
+module RubyHoldem
+  class Round
+    class Player < SimpleDelegator
+      attr_accessor :hole_cards, :current_bet_amount
+
+      def initialize(player)
+        @hole_cards = []
+        @current_bet_amount = 0
+        super(player)
+      end
+    end
+  end
+end

data/lib/ruby_holdem/version.rb

@@ -1,3 +1,3 @@
 module RubyHoldem
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/round/move_factory_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+
+describe RubyHoldem::Round::MoveFactory do
+  describe "#build" do
+    let(:round) { double(RubyHoldem::Round) }
+    let(:stage) { RubyHoldem::Round::STAGES.first }
+    let(:player) { double(RubyHoldem::Round::Player) }
+
+    subject { move_factory.build }
+
+    context "with a move_type of call" do
+      let(:move_type) { "call" }
+      let(:amount) { nil }
+      let(:move_factory) { RubyHoldem::Round::MoveFactory.new(round, player, move_type, amount) }
+      let(:highest_bet_placed) { 100 }
+      let(:current_bet_amount) { 90 }
+      let(:expected_amount) { highest_bet_placed - current_bet_amount }
+
+      before do
+        allow(round).to receive(:stage).and_return(stage)
+        allow(round).to receive(:highest_bet_placed).and_return(highest_bet_placed)
+        allow(player).to receive(:current_bet_amount).and_return(current_bet_amount)
+      end
+
+      it do
+        is_expected.to eq(
+          player: player,
+          stage: stage,
+          move_type: move_type,
+          amount: expected_amount
+        )
+      end
+    end
+
+    {
+      "raise" => 10,
+      "check" => nil,
+      "fold" => nil
+    }.each do |move_type, amount|
+      context "with a move_type of #{move_type}" do
+        let(:move_factory) { RubyHoldem::Round::MoveFactory.new(round, player, move_type, amount) }
+
+        before do
+          allow(round).to receive(:stage).and_return(stage)
+        end
+
+        it do
+          is_expected.to eq(
+            player: player,
+            stage: stage,
+            move_type: move_type,
+            amount: amount
+          )
+        end
+      end
+    end
+  end
+end

data/spec/round/move_history_computations_spec.rb

@@ -0,0 +1,274 @@
+require 'spec_helper'
+
+describe RubyHoldem::Round::MoveHistoryComputations do
+  let(:player1) { RubyHoldem::Round::Player.new("Jack") }
+  let(:player2) { RubyHoldem::Round::Player.new("Joe") }
+  let(:player3) { RubyHoldem::Round::Player.new("Jil") }
+  let(:players) { [player1, player2, player3] }
+
+  let(:moves) { [] }
+  let(:stage) { RubyHoldem::Round::STAGES.first }
+  let(:move_history) { RubyHoldem::Round::MoveHistory.new }
+  let(:move_history_computations) do
+    RubyHoldem::Round::MoveHistoryComputations.new(players, move_history)
+  end
+
+  before do
+    allow(move_history).to receive(:moves).and_return(moves)
+    allow(move_history).to receive(:stage).and_return(stage)
+  end
+
+  describe "#highest_bet_placed" do
+    before do
+      allow(player1).to receive(:current_bet_amount).and_return(0)
+      allow(player2).to receive(:current_bet_amount).and_return(5)
+      allow(player3).to receive(:current_bet_amount).and_return(10)
+    end
+
+    subject { move_history_computations.highest_bet_placed }
+
+    it { is_expected.to eq(10) }
+  end
+
+  describe "#ready_for_next_stage?" do
+    context "not every player has checked yet" do
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 10, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: nil, move_type: 'fold' },
+          { stage: 'pre_flop', player: players[2], amount: nil, move_type: 'check' },
+          { stage: 'pre_flop', player: players[0], amount: nil, move_type: 'check' },
+        ]
+      end
+
+      subject { move_history_computations.ready_for_next_stage? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "no turns have been played yet in this stage" do
+      let(:moves) { [] }
+
+      subject { move_history_computations.ready_for_next_stage? }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe "#has_winner?" do
+    context "round won after every other player folds" do
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 1, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: 4, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[2], amount: 0, move_type: 'fold'},
+          { stage: 'pre_flop', player: players[0], amount: 3, move_type: 'check' },
+          { stage: 'flop', player: players[1], amount: 0, move_type: 'check' },
+          { stage: 'flop', player: players[0], amount: 0, move_type: 'fold' }
+        ]
+      end
+
+      subject { move_history_computations.has_winner? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "in stage showdown" do
+      let(:stage) { RubyHoldem::Round::STAGES.last }
+
+      subject { move_history_computations.has_winner? }
+
+      it { is_expected.to be_truthy }
+    end
+  end
+
+  describe "#winner" do
+    context "round won after every other player folds" do
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 1, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: 4, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[2], amount: 0, move_type: 'fold'},
+          { stage: 'pre_flop', player: players[0], amount: 3, move_type: 'check' },
+          { stage: 'flop', player: players[1], amount: 0, move_type: 'check' },
+          { stage: 'flop', player: players[0], amount: 0, move_type: 'fold' }
+        ]
+      end
+
+      subject { move_history_computations.winner }
+
+      it "returns the only player who hasn't folded" do
+        is_expected.to eq(players[1])
+      end
+    end
+
+    context "in stage showdown" do
+      let(:stage) { RubyHoldem::Round::STAGES.last }
+
+      subject { move_history_computations.winner }
+
+      xit "returns the player with the better hand" do
+
+      end
+    end
+  end
+
+  describe "#turns_played_in_stage" do
+    context "no turns played" do
+      let(:moves) { [] }
+
+      subject { move_history_computations.turns_played_in_stage }
+
+      it { is_expected.to eq(0) }
+    end
+
+    context "turns played in pre_flop" do
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 1, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: 4, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[2], amount: 0, move_type: 'fold'},
+        ]
+      end
+
+      subject { move_history_computations.turns_played_in_stage }
+
+      it { is_expected.to eq(3) }
+    end
+
+    context "turns played in pre_flop but no turns played in flop" do
+      let(:stage) { 'flop' }
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 1, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: 4, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[2], amount: 0, move_type: 'fold'},
+          { stage: 'pre_flop', player: players[0], amount: 3, move_type: 'check' }
+        ]
+      end
+
+      subject { move_history_computations.turns_played_in_stage }
+
+      it { is_expected.to eq(0) }
+    end
+
+    context "turns played in pre_flop and turns played in flop" do
+      let(:stage) { 'flop' }
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 1, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: 4, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[2], amount: 0, move_type: 'fold'},
+          { stage: 'pre_flop', player: players[0], amount: 3, move_type: 'check' },
+          { stage: 'flop', player: players[1], amount: 0, move_type: 'check' },
+          { stage: 'flop', player: players[0], amount: 0, move_type: 'fold' }
+        ]
+      end
+
+      subject { move_history_computations.turns_played_in_stage }
+
+      it { is_expected.to eq(2) }
+    end
+  end
+
+  describe "#player_in_turn" do
+    context "no turns played" do
+      let(:moves) { [] }
+
+      subject { move_history_computations.player_in_turn }
+
+      it { is_expected.to eq(player1) }
+    end
+
+    context "two turns played" do
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 2, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: 4, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[2], move_type: 'fold' }
+        ]
+      end
+
+      subject { move_history_computations.player_in_turn }
+
+      it { is_expected.to eq(player1) }
+    end
+
+    context "many turns played" do
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 2, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: 4, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[2], move_type: 'fold' },
+          { stage: 'pre_flop', player: players[0], move_type: 'call' },
+          { stage: 'pre_flop', player: players[1], move_type: 'check' }
+        ]
+      end
+
+      subject { move_history_computations.player_in_turn }
+
+      it { is_expected.to eq(player1) }
+    end
+  end
+
+  describe "#every_player_has_checked?" do
+    context "every player has checked yet" do
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 10, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: nil, move_type: 'fold' },
+          { stage: 'pre_flop', player: players[2], amount: nil, move_type: 'check' },
+          { stage: 'pre_flop', player: players[0], amount: nil, move_type: 'check' },
+        ]
+      end
+
+      subject { move_history_computations.every_player_has_checked? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context "not every player has checked yet" do
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 10, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: nil, move_type: 'fold' },
+          { stage: 'pre_flop', player: players[2], amount: nil, move_type: 'check' }
+        ]
+      end
+
+      subject { move_history_computations.every_player_has_checked? }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe "#players_still_in_round" do
+    context "no players have folded" do
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 10, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: 10, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[2], amount: 10, move_type: 'raise' }
+        ]
+      end
+
+      subject { move_history_computations.players_still_in_round }
+
+      it { is_expected.to eq([player1, player2, player3]) }
+    end
+
+    context "a player has folded" do
+      let(:moves) do
+        [
+          { stage: 'pre_flop', player: players[0], amount: 10, move_type: 'raise' },
+          { stage: 'pre_flop', player: players[1], amount: nil, move_type: 'fold' },
+          { stage: 'pre_flop', player: players[2], amount: nil, move_type: 'check' }
+        ]
+      end
+
+      subject { move_history_computations.players_still_in_round }
+
+      it { is_expected.to eq([player1, player3]) }
+    end
+  end
+end

data/spec/round/move_history_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe RubyHoldem::Round::MoveHistory do
+  let(:player1) { RubyHoldem::Round::Player.new("Jack") }
+  let(:player2) { RubyHoldem::Round::Player.new("Joe") }
+  let(:player3) { RubyHoldem::Round::Player.new("Jil") }
+  let(:players) { [player1, player2, player3] }
+
+  let(:move_history) { RubyHoldem::Round::MoveHistory.new }
+
+  describe "#add_move" do
+    let(:move) { double }
+
+    subject! { move_history.add_move(move) }
+
+    it { expect(move_history.moves.last).to eq(move) }
+  end
+
+  describe "#last_move" do
+    let(:move) { double }
+
+    before do
+      move_history.add_move(move)
+    end
+
+    subject { move_history.last_move }
+
+    it { is_expected.to eq(move) }
+  end
+
+  describe "#turns_played" do
+    subject { move_history.turns_played }
+
+    it { is_expected.to eq(0) }
+  end
+
+  describe "#next_stage" do
+    subject! { move_history.next_stage }
+
+    it { expect(move_history.stage).to eq(RubyHoldem::Round::STAGES[1]) }
+  end
+end

data/spec/round/move_validator_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+
+describe RubyHoldem::Round::MoveValidator do
+  describe "#validate" do
+    let(:round) { double(RubyHoldem::Round) }
+    let(:player) { double(RubyHoldem::Round::Player) }
+
+    context "with a move_type of raise" do
+      pending
+    end
+
+    context "with a move_type of call" do
+      pending
+    end
+
+    context "with a move_type of check" do
+      pending
+    end
+
+    context "with a move_type of fold" do
+      pending
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_holdem
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Evan Rolfe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-28 00:00:00.000000000 Z
+date: 2016-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-poker
@@ -101,7 +101,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -114,11 +113,18 @@ files:
 - lib/ruby_holdem/errors.rb
 - lib/ruby_holdem/game.rb
 - lib/ruby_holdem/round.rb
-- lib/ruby_holdem/round_player.rb
+- lib/ruby_holdem/round/move_factory.rb
+- lib/ruby_holdem/round/move_history.rb
+- lib/ruby_holdem/round/move_history_computations.rb
+- lib/ruby_holdem/round/move_validator.rb
+- lib/ruby_holdem/round/player.rb
 - lib/ruby_holdem/version.rb
 - ruby_holdem.gemspec
 - spec/dealer_spec.rb
-- spec/round_spec.rb
+- spec/round/move_factory_spec.rb
+- spec/round/move_history_computations_spec.rb
+- spec/round/move_history_spec.rb
+- spec/round/move_validator_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/evanrolfe/ruby-holdem
 licenses:
@@ -146,5 +152,8 @@ specification_version: 4
 summary: A gem for playing texas-holdem poker
 test_files:
 - spec/dealer_spec.rb
-- spec/round_spec.rb
+- spec/round/move_factory_spec.rb
+- spec/round/move_history_computations_spec.rb
+- spec/round/move_history_spec.rb
+- spec/round/move_validator_spec.rb
 - spec/spec_helper.rb

data/.rspec

@@ -1 +0,0 @@
---require spec_helper

data/lib/ruby_holdem/round_player.rb

@@ -1,11 +0,0 @@
-module RubyHoldem
-  class RoundPlayer < SimpleDelegator
-    attr_accessor :hole_cards, :current_bet_amount
-
-    def initialize(player)
-      @hole_cards = []
-      @current_bet_amount = 0
-      super(player)
-    end
-  end
-end

data/spec/round_spec.rb

@@ -1,249 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-
-describe RubyHoldem::Round do
-  let(:player1) { OpenStruct.new(name: "Player #1") }
-  let(:player2) { OpenStruct.new(name: "Player #2") }
-  let(:player3) { OpenStruct.new(name: "Player #3") }
-  let(:players) { [player1, player2, player3] }
-
-  let(:round) { RubyHoldem::Round.new(players, 1, 2) }
-
-  describe '#initialize' do
-    subject { round }
-
-    # TODO: Convert all instances of "should" to "is_expected"
-    its(:small_blinds) { should eq(1) }
-    its(:big_blinds) { should eq(2) }
-    its(:current_stage) { should eq('pre_flop') }
-    its(:action_history) { should eq([]) }
-  end
-
-  describe '#next_stage' do
-    before do
-      allow(round).to receive(:action_history).and_return(action_history)
-    end
-
-    context 'on the pre_flop' do
-      # TODO: Convert the stubbing of the action_history to a sequence of make_move calls in a
-      #       before block
-      let(:action_history) do
-        [
-          { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
-          { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' },
-          { stage: 'pre_flop', player: round.players[2], amount: 1, move: 'call' },
-          { stage: 'pre_flop', player: round.players[0], amount: 0, move: 'call' }
-        ]
-      end
-
-      before do
-        round.next_stage
-      end
-
-      it { expect(round.current_stage).to eq('flop') }
-    end
-  end
-
-  describe '#ready_for_next_stage?' do
-    before do
-      allow(round).to receive(:action_history).and_return(action_history)
-    end
-
-    subject { round.ready_for_next_stage? }
-
-    context 'on game start' do
-      let(:action_history) { [] }
-
-      it { should eq(false) }
-    end
-
-    context 'on the pre_flop' do
-
-      context 'situation 1' do
-        let(:action_history) do
-          [
-            { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
-            { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' }
-          ]
-        end
-        it { should eq(false) }
-      end
-
-      context 'situation 2' do
-        let(:action_history) do
-          [
-            { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
-            { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' },
-            { stage: 'pre_flop', player: round.players[2], amount: 1, move: 'call' },
-            { stage: 'pre_flop', player: round.players[0], amount: 0, move: 'call' }
-          ]
-        end
-
-        it { should eq(true) }
-      end
-
-    end
-
-    context 'on the flop' do
-
-      context 'situation 1' do
-        let(:action_history) do
-          [
-            { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
-            { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' },
-            { stage: 'pre_flop', player: round.players[2], amount: 1, move: 'call' },
-            { stage: 'flop', player: round.players[0], amount: 1, move: 'bet' }
-          ]
-        end
-
-        before do
-          allow(round).to receive(:current_stage).and_return('flop')
-        end
-
-        it { should eq(false) }
-      end
-
-      context 'situation 2' do
-        let(:action_history) do
-          [
-            { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
-            { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' },
-            { stage: 'pre_flop', player: round.players[2], amount: 1, move: 'call' },
-            { stage: 'pre_flop', player: round.players[0], amount: 0, move: 'call' },
-            { stage: 'flop', player: round.players[0], amount: 3, move: 'bet' },
-            { stage: 'flop', player: round.players[2], amount: 3, move: 'call' },
-            { stage: 'flop', player: round.players[0], amount: 0, move: 'call' }
-          ]
-        end
-
-        before do
-          allow(round).to receive(:current_stage).and_return('flop')
-        end
-
-        it { should eq(true) }
-      end
-
-    end
-  end
-
-  describe '#player_in_turn' do
-    let(:action_history) do
-      [
-        { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
-        { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' }
-      ]
-    end
-
-    before do
-      allow(round).to receive(:action_history).and_return(action_history)
-    end
-
-    subject { round.send(:player_in_turn) }
-
-    it { should == round.players[2] }
-  end
-
-  describe '#players_still_in_round' do
-    let(:action_history) do
-      [
-        { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
-        { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' }
-      ]
-    end
-
-    before do
-      allow(round).to receive(:action_history).and_return(action_history)
-    end
-
-    subject { round.send(:players_still_in_round) }
-
-    its([0]) { should eq(round.players[0]) }
-    its([1]) { should eq(round.players[2]) }
-  end
-
-  describe '#highest_bet_placed' do
-    before do
-      round.make_move('call')
-      round.make_move('call')
-      round.make_move('bet', 4)
-    end
-
-    subject { round.send(:highest_bet_placed) }
-
-    it { should eq(4) }
-  end
-
-  describe '#has_winner?' do
-    subject { round.has_winner? }
-
-    context 'round won after folds' do
-      let(:action_history) do
-        [
-          { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
-          { stage: 'pre_flop', player: round.players[1], amount: 4, move: 'bet' },
-          { stage: 'pre_flop', player: round.players[2], amount: 0, move: 'fold'},
-          { stage: 'pre_flop', player: round.players[0], amount: 3, move: 'call' },
-          { stage: 'flop', player: round.players[1], amount: 0, move: 'call' },
-          { stage: 'flop', player: round.players[0], amount: 0, move: 'fold' }
-        ]
-      end
-
-      before do
-        allow(round).to receive(:action_history).and_return(action_history)
-      end
-
-      it { should eq(true) }
-    end
-
-    context 'showdown between remaining players' do
-      before do
-        allow(round).to receive(:current_stage).and_return('show_down')
-      end
-
-      it { should eq(true) }
-    end
-  end
-
-  describe '#winner' do
-
-  end
-
-  describe '#apply_bet' do
-    context 'at the start of the round' do
-      before do
-        round.send(:apply_bet, 1)
-      end
-
-      subject { round }
-
-      its(:action_history) { should eq([{ player: round.players[0], stage: 'pre_flop', move: 'bet', amount: 1 }]) }
-      its(:pot_amount) {  should eq(1) }
-    end
-  end
-
-  describe '#apply_call' do
-    context 'at the start of the round' do
-      before do
-        round.send(:apply_call)
-      end
-
-      subject { round }
-
-      its(:action_history) { should eq([{ player: round.players[0], stage: 'pre_flop', move: 'call', amount: 0 }]) }
-      its(:pot_amount) {  should eq(0) }
-    end
-  end
-
-  describe '#apply_fold' do
-    context 'at the start of the round' do
-      before do
-        round.send(:apply_fold)
-      end
-
-      subject { round }
-
-      its(:action_history) { should eq([{ player: round.players[0], stage: 'pre_flop', move: 'fold', amount: 0 }]) }
-      its(:pot_amount) {  should eq(0) }
-    end
-  end
-end