texas_holdem 0.1.0

data/.autotest

@@ -0,0 +1,5 @@
+begin
+  require 'redgreen/autotest'
+rescue
+  puts "gem install redgreen for colorized output"
+end

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Keith McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= texas_holdem
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Keith McDonnell. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "texas_holdem"
+    gem.summary = %Q{Ruby classes modelling a game Texas Holdem poker}
+    gem.description = %Q{Ruby classes modelling a game Texas Holdem poker}
+    gem.email = "keith@dancingtext.com"
+    gem.homepage = "http://github.com/kmcd/texas_holdem"
+    gem.authors = ["Keith McDonnell"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "texas_holdem #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Create class & unit test'
+task :class, :name do |task,args|
+  class_name = args.name.capitalize
+  file_name  = args.name.downcase
+  
+  write_to "lib/#{file_name}.rb", %Q{class TexasHoldem::#{class_name}
+end}
+
+  write_to "test/test_#{file_name}.rb", %Q{require 'helper'
+class #{class_name}Test < Test::Unit::TestCase
+  def setup
+  end
+  
+  test "should " do
+    flunk
+  end
+end}
+end
+
+def write_to(local_filename,text)
+  File.open(local_filename, 'w') {|f| f.write(text) }
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/betting_round.rb

@@ -0,0 +1,83 @@
+require 'timeout'
+
+class BettingRound
+  attr_accessor :max_wait_time_for_bet
+  
+  def initialize(hand)
+    @hand = hand
+    @betting_circle = players.enum_for
+    players.each {|player| player.add_observer self }
+  end
+  
+  def next_player
+    @current_player = @betting_circle.next
+    rescue StopIteration
+      @betting_circle.rewind and retry
+  end
+  
+  def max_wait_time_for_bet(seconds)
+    Timeout::timeout(seconds) { yield }
+    rescue Timeout::Error
+      fold @current_player and next_player
+  end
+  
+  def current_player
+    @current_player || next_player
+  end
+  
+  def players
+    @players ||= @hand.players
+  end
+  
+  def bets
+    @bets ||= Hash.new(0)
+  end
+  
+  def minimum_bet
+    bets.values.empty? ? @hand.minimum_bet : amount_to_match_pot
+  end
+  
+  def minimum_raise
+    minimum_bet + @hand.minimum_bet
+  end
+  
+  def amount_bet
+    bets.values.compact.reduce(:+) || 0
+  end
+  
+  def finished?
+    players.size == 1 || everyone_bet_equal_amount? 
+  end
+  
+  def update(args)
+    if args[:fold]
+      fold @current_player
+    else
+      bet, player = args[:bet][:amount], args[:bet][:player] 
+      return unless valid? bet, player
+      bets[player] += bet
+      @hand.pot += bet
+    end
+    next_player
+  end
+  
+  private
+  
+  def valid?(bet,player)
+    return unless player.eql? current_player
+    bet == minimum_bet || bet >= minimum_raise || bet == 0
+  end
+  
+  def everyone_bet_equal_amount?
+    bets.values.uniq.size == 1
+  end
+  
+  def amount_to_match_pot
+    bets.values.max - bets[current_player]
+  end
+  
+  def fold(player)
+    players.delete player
+    @hand.fold player
+  end
+end

data/lib/deck.rb

@@ -0,0 +1,35 @@
+class TexasHoldem::Deck
+  FACES, SUITS = "AKQJT98765432", "cdhs"
+    
+  attr_reader :cards
+  
+  def initialize
+    build
+    shuffle
+  end
+  
+  def next_card
+    @cards.pop
+  end
+  
+  private
+  
+  def build
+    @cards = []                            
+    
+    FACES.each_byte do |f|
+      SUITS.each_byte {|s| @cards.push(f.chr + s.chr) }
+    end
+  end
+  
+  def shuffle
+    3.times do                            
+      shuf = []
+      @cards.each do |c|
+        loc = rand(shuf.size + 1)
+        shuf.insert(loc, c)
+      end
+      @cards = shuf.reverse
+    end
+  end
+end

data/lib/game.rb

@@ -0,0 +1,20 @@
+class TexasHoldem::Game
+  SMALL_BLIND_PERCENTAGE = 0.0125
+  attr_reader :players, :entrance_fee
+  
+  def initialize(players,entrance_fee)
+    @players, @entrance_fee = players, entrance_fee
+  end
+  
+  def finished?
+    players.size == 1
+  end
+  
+  def winner
+    players.first if finished?
+  end
+  
+  def small_blind
+    @entrance_fee * SMALL_BLIND_PERCENTAGE
+  end
+end

data/lib/hand.rb

@@ -0,0 +1,78 @@
+require 'enumerated_attribute'
+
+class TexasHoldem::Hand
+  enum_attr :round, %w( ^pocket flop turn river showdown )
+  attr_reader :players, :community_cards
+  attr_accessor :pot
+  
+  def initialize(players, small_blind_amount=1)
+    @players = players
+    @deck = TexasHoldem::Deck.new
+    @community_cards = []
+    @small_blind_amount = small_blind_amount
+    @pot = 0 # Should this be an Observer?
+  end
+  
+  def dealer
+    @players.first
+  end
+  
+  def minimum_bet
+    @small_blind_amount * 2
+  end
+  
+  def small_blind
+    return dealer if players_remaining? 2
+    @players[2]
+  end
+  
+  def big_blind
+    return @players.last if players_remaining? 2
+    @players[1]
+  end
+  
+  def winner
+    if finished?
+      @players.first.take_winnings @pot
+      @players.first
+    end
+  end
+  
+  def finished?
+    players_remaining? 1
+  end
+  
+  def fold(player)
+    @players.delete player
+  end
+  
+  def deal
+    case round
+      when :pocket : deal_pocket_cards && deduct_blinds # Move to BettingRound?
+      when :flop   : deal_community_cards 3
+      when :turn   : deal_community_cards 1
+      when :river  : deal_community_cards 1
+    end
+  end
+  
+  private
+  
+  def players_remaining?(number)
+    @players.size == number
+  end
+  
+  def deal_pocket_cards
+    @players.each do |player| 
+      2.times { player.cards << @deck.next_card }
+    end
+  end
+  
+  def deal_community_cards(number)
+    number.times { @community_cards << @deck.next_card }
+  end
+  
+  def deduct_blinds
+    @pot += small_blind.bet(@small_blind_amount)
+    @pot += big_blind.bet(@small_blind_amount * 2)
+  end
+end

data/lib/player.rb

@@ -0,0 +1,42 @@
+class NotEnoughCashError < StandardError
+end
+
+require 'observer'
+
+class TexasHoldem::Player
+  attr_reader :name, :cards, :cash
+  include Observable
+  
+  def initialize(name,cash)
+    @name, @cash = name, cash
+    @cards = []
+  end
+  
+  def bet(amount)
+    # TODO: add remaining cash instead of raising an error
+    raise NotEnoughCashError unless enough_cash_for?(amount)
+    @cash -= amount
+    changed true
+    notify_observers :bet => { :player => self, :amount => amount }
+    amount
+  end
+  
+  def check
+    bet 0
+  end
+  
+  def fold
+    changed true
+    notify_observers :fold => true
+  end
+  
+  def take_winnings(amount)
+    @cash += amount
+  end
+  
+  private
+  
+  def enough_cash_for?(amount)
+    @cash > amount
+  end
+end 

data/lib/players_hand.rb

@@ -0,0 +1,132 @@
+# TODO: rename to PlayerHand or Player::Hand
+class TexasHoldem::PlayersHand
+  attr_reader :cards
+  
+  include Comparable
+  
+  # TODO: dry up [scdh] references
+  MATCHES = { 
+    'one pair'        => /(\d{1,2})[scdh] (?:\s\1[scdh]){1}/x,
+    'two pair'        => /(\d{1,2})[scdh] \1[scdh].*(\d{1,2})[scdh] \2[scdh]/,
+    'three of a kind' => /(\d{1,2})[scdh] (?:\s\1[scdh]){2}/x,
+    'four of a kind'  => /(\d{1,2})[scdh] (?:\s\1[scdh]){3}/x,
+  }                                                                           
+
+  def initialize(cards)
+    @cards = cards
+    @cards.gsub!(/J/, '11')
+    @cards.gsub!(/Q/, '12')
+    @cards.gsub!(/K/, '13')
+    @cards.gsub!(/A/, '14')
+    @cards = @cards.split.sort_by {|c| c.gsub(/\D/,'').to_i }.join ' '
+  end
+  
+  def <=>(players_hand)
+    if score == players_hand.score
+      remaining_cards <=> players_hand.remaining_cards
+    else
+      score <=> players_hand.score
+    end
+  end
+                                  
+  def name
+    # TODO: refactor to polymorphic type?
+    if four_of_a_kind?
+      'four of a kind'
+    elsif full_house?   
+      'full house'
+    elsif flush?
+      'flush'
+    elsif straight?
+      'straight'
+    elsif three_of_a_kind?
+      'three of a kind'
+    elsif two_pair?
+      'two pair'
+    elsif one_pair?
+      'one pair'
+    else
+      'high card'
+    end
+  end
+  
+  def one_pair?
+    @cards.match MATCHES['one pair']
+  end
+  
+  def two_pair?
+    @cards.match MATCHES['two pair']
+  end
+  
+  def straight?
+    card_sequence = face_values.split.map {|d| d.to_i }
+    (card_sequence.first..card_sequence.last).to_a == card_sequence
+  end       
+  
+  def flush?
+    @cards.match /\d{1,2}([csdh]) (?:\s\d{1,2}\1){4} /x
+  end
+  
+  def three_of_a_kind?
+    @cards.match MATCHES['three of a kind']
+  end
+  
+  def full_house?
+    # TODO: change this to [csdh]
+    @cards.gsub(/\D/,'').match /^(?:(\d) \1{2} (\d) \2|(\d) \3 (\d) \4{2})/x
+  end    
+  
+  def four_of_a_kind?
+    @cards.match MATCHES['four of a kind']
+  end
+  
+  protected
+  
+  def score
+    base_score + relative_score
+  end
+  
+  def base_score
+    case name
+      when /one pair/   : 1
+      when /two pair/   : 2
+      when /three/      : 3
+      when /straight/   : 4
+      when /flush/      : 5
+      when /full house/ : 6
+      when /four/       : 7
+    else
+      0
+    end * 1000
+  end
+  
+  def relative_score
+    case name
+      when /one pair/   : @cards[MATCHES['one pair'],1].to_i * 2
+      when /two pair/   : @cards[MATCHES['two pair'],2].to_i * 2
+      when /three/      : @cards[MATCHES['three of a kind'],1].to_i * 3
+      when /straight/   : face_values.split.last.to_i
+      when /flush/      : face_values.split.sort.last.to_i
+      when /full house/ : @cards[MATCHES['three of a kind'],1].to_i
+      when /four/       : @cards[MATCHES['four of a kind'],1].to_i
+    else
+      0
+    end                         
+  end
+  
+  def remaining_cards
+    case name
+      when /high card/ : @cards
+      when /one pair/  : @cards.gsub(MATCHES['one pair'], '')
+      when /two pair/  : @cards.gsub(MATCHES['two pair'], '')
+      else
+        ''
+    end.gsub /[a-z]/, ''
+  end
+  
+  private
+  
+  def face_values
+    @cards.gsub(/[scdh]/,'')
+  end
+end

data/lib/texas_holdem.rb

@@ -0,0 +1,8 @@
+module TexasHoldem
+  require 'game'
+  require 'hand'
+  require 'player'
+  require 'deck'
+  require 'betting_round'
+  require 'players_hand'
+end

data/test/helper.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support/testing/declarative'
+require 'mocha'
+
+# TODO: create a rake task to load irb environment
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'texas_holdem'
+
+class Test::Unit::TestCase
+  extend ActiveSupport::Testing::Declarative
+  
+  def assert_cards(number,players)
+    assert players.all? {|player| player.cards.size == number }
+  end
+end
+
+class String
+  include Test::Unit::Assertions
+  
+  def hand_name(name)
+    assert_equal name, TexasHoldem::PlayersHand.new(self).name
+  end
+  
+  def beats(loser)
+    winner, loser = TexasHoldem::PlayersHand.new(self), TexasHoldem::PlayersHand.new(loser)
+    assert( winner > loser )
+  end
+end
+
+class TexasHoldem::Hand
+  def self.factory(small_blind=1.25)
+    players = %w( Amy Bill Carl ).map {|name| TexasHoldem::Player.factory name }
+    new players, small_blind
+  end
+  
+  def advance_to_round(number)
+    (number - 1).times do
+      deal
+      round_next
+    end
+  end
+end
+
+class TexasHoldem::Player
+  def self.factory(name, cash=100)
+    new name, cash
+  end
+end
+
+module HandTestHelper
+  def setup
+    @hand = TexasHoldem::Hand.factory
+    @amy, @bill, @carl = *@hand.players
+  end
+end

data/test/test_betting_round.rb

@@ -0,0 +1,140 @@
+require 'helper'
+
+class BettingRoundTest < Test::Unit::TestCase
+  include HandTestHelper
+  
+  def setup
+    super
+    @betting_round = BettingRound.new @hand
+    @hand.deal
+  end
+  
+  def assert_current_player(player)
+    assert_equal player, @betting_round.current_player
+  end
+                             
+  test "player to the left of big blind is first to bet" do
+    assert_current_player @amy
+  end
+  
+  test "play continues clockwise around the table" do
+    assert_current_player @amy
+    @betting_round.next_player
+    assert_current_player @bill
+    @betting_round.next_player
+    assert_current_player @carl
+    @betting_round.next_player
+    assert_current_player @amy
+  end
+  
+  test "should track amount bet" do
+    @amy.bet 20
+    assert_equal 20, @betting_round.amount_bet
+    @bill.bet 20
+    assert_equal 40, @betting_round.amount_bet
+    @carl.bet 20
+    assert_equal 60, @betting_round.amount_bet
+  end
+  
+  test "should only accept bet from current player" do
+    assert_current_player @amy
+    @carl.bet 20
+    assert_equal 0, @betting_round.amount_bet
+    assert_current_player @amy
+  end
+  
+  test "should finish if all players check" do
+    @betting_round.players.each {|player| player.check }
+    assert @betting_round.finished?
+  end
+  
+  test "should finish if all players check or fold" do
+    @amy.check
+    @bill.check
+    @carl.fold
+    assert @betting_round.finished?
+  end
+  
+  test "should remove player from hand if they fold" do
+    player = @betting_round.current_player
+    player.fold
+    assert_nil @hand.players.find {|p| p == player }
+  end
+  
+  test "should finish when all but one fold" do
+    @amy.fold
+    @carl.fold
+    assert @betting_round.finished?
+  end
+  
+  test "should have minimum raises equal to big blind" do
+    @amy.bet @hand.minimum_bet - 1
+    assert_equal 0, @betting_round.amount_bet
+    assert_current_player @amy
+  end
+  
+  test "betting finishes when everyone puts in same amount" do
+    @betting_round.players.each {|player| player.bet 10 }
+    assert @betting_round.finished?
+  end
+  
+  test "should calculate minimum bet for current player" do
+    @amy.bet 20
+    
+    assert_current_player @bill
+    assert_equal @betting_round.minimum_bet, 20
+    @bill.bet 30
+    
+    assert_current_player @carl
+    assert_equal @betting_round.minimum_bet, 30
+    @carl.bet 40
+    
+    assert_current_player @amy
+    assert_equal @betting_round.minimum_bet, 20
+    @amy.bet 20
+    
+    assert_current_player @bill
+    assert_equal @betting_round.minimum_bet, 10
+    @bill.bet 10
+  end
+  
+  test "betting finishes when everyone matches amount previously put in" do
+    @amy.bet 20
+    @bill.bet 30
+    @carl.bet 40
+    assert !@betting_round.finished?
+    @amy.bet 20
+    assert !@betting_round.finished?
+    @bill.bet 10
+    assert @betting_round.finished?
+  end
+  
+  test "should enforce (big blind) minumim bet raise" do
+    @amy.bet 10
+    assert_equal 10, @betting_round.minimum_bet
+    assert_equal 12.5, @betting_round.minimum_raise
+    
+    @bill.bet 12
+    assert_current_player @bill
+    
+    @bill.bet 12.5
+    assert_current_player @carl
+  end
+  
+  test "should add bets to the pot" do
+    @amy.bet 20
+    @bill.bet 20
+    @carl.bet 20
+    blinds = 3.75
+    assert_equal 60 + blinds, @hand.pot 
+  end
+  
+  test "should kick player out of the hand if they take too long to bet" do
+    @betting_round.max_wait_time_for_bet(0.09) do
+      assert_current_player @amy
+      sleep 0.1
+      assert !@betting_round.players.include?(@amy)
+      assert_current_player @bill
+    end
+  end
+end

data/test/test_deck.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+SORTED_FULL_DECK = %w[ 2c 2d 2h 2s 3c 3d 3h 3s 4c 4d 4h 4s 5c 5d 5h 5s 6c 6d 6h 6s 
+  7c 7d 7h 7s 8c 8d 8h 8s 9c 9d 9h 9s Ac Ad Ah As Jc Jd Jh Js Kc Kd Kh Ks Qc
+  Qd Qh Qs Tc Td Th Ts]
+    
+class NewDeckTest < Test::Unit::TestCase
+  def setup
+    @deck = TexasHoldem::Deck.new
+  end
+  
+  test "should have 52 cards initially" do
+    assert_equal 52, @deck.cards.size
+  end
+  
+  test "should have 52 unique cards" do
+    assert_equal 52, @deck.cards.uniq.size
+  end
+  
+  test "should have 2 - Ace of Clubs, Spades, Diamonds & Hearts" do
+    assert_equal SORTED_FULL_DECK, @deck.cards.sort
+  end
+end
+
+class DeckDealTest < Test::Unit::TestCase
+  def setup
+    @deck = TexasHoldem::Deck.new
+  end
+  
+  test "should deal the next card" do
+    delt_card = @deck.next_card
+    
+    assert_equal 51, @deck.cards.size
+    assert SORTED_FULL_DECK.include?(delt_card)
+    assert_equal SORTED_FULL_DECK - [delt_card], @deck.cards.sort
+  end
+end

data/test/test_game.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+class GameTest < Test::Unit::TestCase
+  def setup
+    @game = TexasHoldem::Game.new [], 100
+  end
+  
+  test "should not have a winner at game start" do
+    assert_nil @game.winner
+  end
+  
+  test "should have players" do
+    assert_equal [], @game.players
+  end
+  
+  test "should have small blind as 1.25% of entrance fee" do
+    assert_equal 1.25, @game.small_blind
+  end
+  
+  test "should know when finshed" do
+    @game.stubs(:players).returns [TexasHoldem::Player.new('Foo', 100)]
+    assert_equal true, @game.finished?
+  end
+  
+  test "should have a winner when finished" do
+    winner = TexasHoldem::Player.new 'Foo', 100
+    @game.stubs(:players).returns [winner]
+    assert_equal winner, @game.winner
+  end
+end

data/test/test_hand.rb

@@ -0,0 +1,158 @@
+require 'helper'
+
+class HandTest < Test::Unit::TestCase  
+  include HandTestHelper
+  
+  test "should not have a winner initially" do
+    assert_nil @hand.winner
+  end
+  
+  test "should have a winner if everyone else folds" do
+    @hand.deal
+    @hand.fold @bill
+    @hand.fold @carl
+    
+    assert_equal @hand.winner, @amy
+  end
+                 
+  test "automatically deduct blinds after dealing pocket cards" do
+    assert_equal 100, @hand.small_blind.cash
+    assert_equal 100, @hand.big_blind.cash
+    
+    @hand.deal
+    
+    assert @hand.pocket?
+    assert_equal 98.75, @hand.small_blind.cash
+    assert_equal 97.5, @hand.big_blind.cash
+    assert_equal 2.5 + 1.25, @hand.pot
+  end
+  
+  test "should know when finished" do
+    @hand.deal
+    @hand.fold @bill
+    @hand.fold @carl
+    
+    assert_equal true, @hand.finished?
+  end
+  
+  test "pay out winnings when only one player remains" do
+    @hand.deal
+    @hand.fold @hand.small_blind
+    @hand.fold @hand.big_blind
+    
+    assert_equal 103.75, @hand.winner.cash
+  end
+  
+  test "minimum bet is double the small blind" do
+    assert_equal 2.5, @hand.minimum_bet
+  end
+end
+
+class PocketHandTest < Test::Unit::TestCase  
+  include HandTestHelper
+  
+  test "first round should be pocket/hole cards" do
+    assert @hand.pocket?
+  end
+  
+  test "first round should deal two cards to all players" do
+    @hand.deal
+    assert_cards 2, @hand.players
+  end
+  
+  test "should have a dealer" do
+    assert_equal @amy, @hand.dealer
+  end
+  
+  test "should have a big blind player" do
+    assert_equal @bill, @hand.big_blind
+  end
+  
+  test "should have a small blind player" do
+    assert_equal @carl, @hand.small_blind
+  end
+end     
+
+class FlopTest < Test::Unit::TestCase 
+  include HandTestHelper
+  
+  def setup
+    super
+    @hand.advance_to_round 2
+    @hand.deal
+  end
+  
+  test "second round should be the flop" do
+    assert @hand.flop?
+  end
+  
+  test "second round should deal no new cards to any players" do
+    assert_cards 2, @hand.players
+  end
+  
+  test "second round should deal three community cards" do
+    assert_equal 3, @hand.community_cards.size
+  end
+end
+
+class TurnTest < Test::Unit::TestCase 
+  include HandTestHelper
+  
+  def setup
+    super
+    @hand.advance_to_round 3
+    @hand.deal
+  end
+  
+  test "third round should be the turn" do
+    assert @hand.turn?
+  end
+  
+  test "third round should deal no new cards to any players" do
+    assert_cards 2, @hand.players
+  end
+  
+  test "second round should deal one extra community card" do
+    assert_equal 4, @hand.community_cards.size
+  end
+end
+                         
+class RiverTest < Test::Unit::TestCase 
+  include HandTestHelper
+  
+  def setup
+    super
+    @hand.advance_to_round 4
+    @hand.deal
+  end
+  
+  test "third round should be the river" do
+    assert @hand.river?
+  end
+  
+  test "third round should deal no new cards to any players" do
+    assert_cards 2, @hand.players
+  end
+  
+  test "second round should deal one extra community card" do
+    assert_equal 5, @hand.community_cards.size
+  end
+end
+
+class TwoPlayerHandTest < Test::Unit::TestCase
+  include HandTestHelper
+  
+  def setup
+    super
+    @hand = TexasHoldem::Hand.new [@bill, @carl]
+  end
+                                                              
+  test "should have the dealer as the small blind" do       
+    assert_equal @hand.dealer, @bill
+    assert_equal @hand.small_blind, @bill
+  end              
+  
+  test "should have second player as big blind" do
+    assert_equal @hand.big_blind, @carl
+  end
+end

data/test/test_player.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+class PlayerTest < Test::Unit::TestCase
+  def setup
+    @entrance_fee = 100
+    @player = TexasHoldem::Player.new 'Carl', @entrance_fee
+  end
+  
+  test "should have a name" do
+    assert_equal 'Carl', @player.name
+  end
+  
+  test "should have no cards initially" do
+    assert @player.cards.empty?
+  end
+  
+  test "should have cash" do
+    assert_equal @entrance_fee, @player.cash
+  end
+  
+  test "should place a bet" do
+    @player.bet 99
+    assert_equal 1, @player.cash
+  end
+  
+  test "should NOT bet more than available cash" do
+    # FIXME: treat as all in insead of raising an error
+    assert_raises(NotEnoughCashError) do
+      @player.bet(101)
+    end
+  end
+end

data/test/test_players_hand.rb

@@ -0,0 +1,117 @@
+require 'helper'
+
+class HandTest < Test::Unit::TestCase
+  test "should always have cards sorted in ascending order by face value" do
+    hand = TexasHoldem::PlayersHand.new('Ad As 5c 6c Jd')
+    assert_equal  "5c 6c 11d 14s 14d", hand.cards
+  end
+end
+
+class HandIdentificationTest < Test::Unit::TestCase
+  # TODO: add more non-sequential matches
+  
+  test "should recognise a high card" do
+    '2d 3s 5c 6c Ad'.hand_name 'high card'
+  end
+  
+  test "should recognise a pair" do
+    '2d 2s 5c 6c Ad'.hand_name 'one pair'
+  end
+  
+  test "should recognise two pair" do
+    '2d 2s 5c 5d Ad'.hand_name 'two pair'
+  end
+  
+  test "should recognise three of a kind" do
+    '2d 2s 2h 5d Ad'.hand_name 'three of a kind' 
+  end
+  
+  test "should recognise a straight" do
+    '2d 3s 4h 5d 6d'.hand_name 'straight'
+    '10c Jd Qs Kd As'.hand_name 'straight'
+  end
+  
+  test "should recognise a flush" do
+    '2h 3h 4h 5h 7h'.hand_name 'flush'
+  end
+  
+  test "should recognise a full house" do
+    '2d 2s 2h 4d 4c'.hand_name 'full house'
+    '2d 2s 4h 4d 4c'.hand_name 'full house'
+    '2d 4s 2h 4d 4c'.hand_name 'full house'
+  end
+  
+  test "should recognise four of a kind" do
+    '2d 2c 2s 2h 3c'.hand_name 'four of a kind'
+  end
+end
+
+class WinningHandsTest < Test::Unit::TestCase
+  test "highest card should win if no scoring poker hands" do
+    '2d 3s 5c 6c Ad'.beats '2c 3d 5s 6h Kd'
+  end
+  
+  test "one pair beats no matches" do
+    '2d 2s 5c 6c Ad'.beats '2c 3d 5s 6h Kd'
+  end
+  
+  test "high pair beats low pair" do
+    'Ad As 5c 6c Jd'.beats 'Kc Kd 5s 6h Qd'
+  end
+  
+  test "highest card wins when pairs are equal" do
+    'Ad As 5c 6c Kd'.beats 'Ac Ad 5s 6h Qd'
+  end
+  
+  test "two pair beats a pair" do
+    'Ad As 5c 5d Kd'.beats 'Ac Ad 5s 6h Qd'
+  end
+  
+  test "highest pair wins if both two pairs" do
+    '2d 2s 4c 4d Kd'.beats '2c 2d 3s 3h Qd'
+    'Ad As 4c 4d Kd'.beats 'Kc Kd Qs Qh Jd'
+  end
+  
+  test "highest card wins if both hands have identincal two pairs" do
+    '2d 2s 4c 4d 6d'.beats '2d 2s 4c 4d 5d'
+  end
+  
+  test "three of a kind beats two pair" do
+    'Ad As Ac 5d Kd'.beats 'Kc Kd 5s 5h Qd'
+  end
+  
+  test "stright beats three of a kind" do
+    '2d 3c 4h 5s 6d'.beats 'Ad As Ac 5d Kd'
+  end
+  
+  test "higher stright beats lower straight" do
+    '3c 4h 5s 6d 7d'.beats '2d 3c 4h 5s 6d'
+    '10c Jd Qs Kd As'.beats '9h 10c Jd Qs Kd'
+  end
+  
+  test "flush beats a straight" do
+    '2h 3h 4h 5h 7h'.beats '9h 10c Jd Qs Kd'
+  end
+  
+  test "high card determines winner of flushes" do
+    '2h 3h 4h 5h 8h'.beats '2d 3d 4d 5d 7d'
+  end
+  
+  test "full house beats a flush" do
+    '2d 2s 2h 4d 4c'.beats '2d 3d 4d 5d 7d'
+  end
+  
+  test "higher three of a kind determines full house winner" do
+    '3d 3s 3h 4d 4c'.beats '2s 2h 2c Ad Ac'
+    'Ad As Ah 4d 4c'.beats 'Ks Kh Kc Ad Ac'
+  end
+  
+  test "four of a kind beats a full house" do
+    '2d 2c 2s 2h 3c'.beats '3d 3s 3h 4d 4c'
+  end
+  
+  test "higher card determines four of a kind winner" do
+    '3d 3c 3s 3h 4c'.beats '2d 2c 2s 2h 5c'
+    'Ad Ac As Ah 4c'.beats 'Kd Kc Ks Kh 5c'
+  end
+end

data/test/test_texas_holdem.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class TexasHoldemTest < Test::Unit::TestCase
+  def setup
+  end
+  
+  test "should have end to end tests here" do
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: texas_holdem
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Keith McDonnell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-29 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Ruby classes modelling a game Texas Holdem poker
+email: keith@dancingtext.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+- README.rdoc
+files: 
+- .autotest
+- .document
+- .gitignore
+- Gemfile
+- LICENSE
+- README
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/betting_round.rb
+- lib/deck.rb
+- lib/game.rb
+- lib/hand.rb
+- lib/player.rb
+- lib/players_hand.rb
+- lib/texas_holdem.rb
+- test/helper.rb
+- test/test_betting_round.rb
+- test/test_deck.rb
+- test/test_game.rb
+- test/test_hand.rb
+- test/test_player.rb
+- test/test_players_hand.rb
+- test/test_texas_holdem.rb
+has_rdoc: true
+homepage: http://github.com/kmcd/texas_holdem
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby classes modelling a game Texas Holdem poker
+test_files: 
+- test/test_game.rb
+- test/test_player.rb
+- test/test_betting_round.rb
+- test/test_hand.rb
+- test/test_deck.rb
+- test/test_players_hand.rb
+- test/helper.rb
+- test/test_texas_holdem.rb