texas_holdem 0.1.0 → 0.2.0

data/.gitignore

@@ -17,5 +17,6 @@ tmtags
 coverage
 rdoc
 pkg
+*.gemspec
 
 ## PROJECT::SPECIFIC

data/README.rdoc

@@ -1,6 +1,6 @@
 = texas_holdem
 
-Description goes here.
+Ruby classes modelling a game Texas Holdem poker
 
 == Note on Patches/Pull Requests
  

data/Rakefile

@@ -47,6 +47,7 @@ task :class, :name do |task,args|
 end}
 
   write_to "test/test_#{file_name}.rb", %Q{require 'helper'
+  
 class #{class_name}Test < Test::Unit::TestCase
   def setup
   end

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/deck.rb

@@ -17,17 +17,17 @@ class TexasHoldem::Deck
   def build
     @cards = []                            
     
-    FACES.each_byte do |f|
-      SUITS.each_byte {|s| @cards.push(f.chr + s.chr) }
+    FACES.each_byte do |face|
+      SUITS.each_byte {|suit| @cards.push(face.chr + suit.chr) }
     end
   end
   
   def shuffle
     3.times do                            
       shuf = []
-      @cards.each do |c|
+      @cards.each do |card|
         loc = rand(shuf.size + 1)
-        shuf.insert(loc, c)
+        shuf.insert(loc, card)
       end
       @cards = shuf.reverse
     end

data/lib/hand.rb

@@ -32,10 +32,10 @@ class TexasHoldem::Hand
   end
   
   def winner
-    if finished?
-      @players.first.take_winnings @pot
-      @players.first
-    end
+    return unless finished?
+    winning_player = @players.first
+    winning_player.take_winnings @pot
+    winning_player
   end
   
   def finished?
@@ -48,7 +48,7 @@ class TexasHoldem::Hand
   
   def deal
     case round
-      when :pocket : deal_pocket_cards && deduct_blinds # Move to BettingRound?
+      when :pocket : deal_pocket_cards && deduct_blinds
       when :flop   : deal_community_cards 3
       when :turn   : deal_community_cards 1
       when :river  : deal_community_cards 1

data/lib/player_hand.rb

@@ -0,0 +1,220 @@
+module TexasHoldem
+  class PlayerHand
+    attr_reader :cards
+    include Comparable
+    
+    def self.inherited(subclass)
+      (@hand_types || @hand_types = []) << subclass
+    end
+    
+    # TODO: investigate Builder / Factory pattern
+    def self.create(cards)
+      # cards could be both OnePair and a FullHouse, so return the highest raking hand
+      @hand_types.map {|hand| hand.create(cards) }.compact.sort_by(&:score).last
+    end
+    
+    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 {|card| card.gsub(/\D/,'').to_i }.join ' '
+    end
+    
+    def <=>(players_hand)
+      other_players_hand_score = players_hand.score
+      this_players_score = score
+      
+      if this_players_score == other_players_hand_score
+        remaining_cards <=> players_hand.remaining_cards
+      else
+        this_players_score <=> other_players_hand_score
+      end
+    end
+    
+    def score
+      base_score * 1000 + relative_score
+    end
+    
+    def remaining_cards
+      @cards.gsub /\D/, ''
+    end
+    
+    private
+    
+    def face_values
+      @cards.gsub(/[scdh]/,'')
+    end
+    
+    def face_values_array
+      face_values.to_a
+    end
+  end
+    
+  class FourOfAKind < PlayerHand
+    Pattern = /(\d{1,2})[scdh] (?:\s\1[scdh]){3}/x
+    
+    def self.create(cards)
+      new cards if cards.match Pattern
+    end
+    
+    def name
+      'four of a kind'
+    end
+    
+    def base_score
+      7
+    end
+    
+    def relative_score
+      @cards[Pattern,1].to_i
+    end
+  end
+  
+  class FullHouse < PlayerHand
+    Pattern =  /^(?:(\d) \1{2} (\d) \2|(\d) \3 (\d) \4{2})/x
+    
+    def self.create(cards)
+      new(cards) if cards.gsub(/\D/,'').split(//).sort.to_s.match Pattern
+    end
+    
+    def name
+      'full house'
+    end
+    
+    def base_score
+      6
+    end
+    
+    def relative_score
+      @cards[ TexasHoldem::ThreeOfAKind::Pattern, 1 ].to_i
+    end
+  end
+  
+  class Flush < PlayerHand
+    Pattern = /\d{1,2}([csdh]) (?:\s\d{1,2}\1){4} /x
+    
+    def self.create(cards)
+      new(cards) if cards.match Pattern
+    end
+    
+    def name
+      'flush'
+    end
+    
+    def base_score
+      5
+    end
+    
+    def relative_score
+      face_values_array.sort.last.to_i
+    end
+  end
+  
+  class Straight < PlayerHand
+    def self.create(cards)
+      straight = new cards
+      card_values = straight.cards.gsub(/[scdh]/,'').split.map {|card_value| card_value.to_i }
+      new(cards) if (card_values.first..card_values.last).to_a == card_values
+    end
+    
+    def name
+      'straight'
+    end
+    
+    def base_score
+      4
+    end
+    
+    def relative_score
+      face_values_array.last.to_i
+    end
+  end
+  
+  class ThreeOfAKind < PlayerHand
+    Pattern = /(\d{1,2})[scdh] (?:\s\1[scdh]){2}/x
+    
+    def self.create(cards)
+      new(cards) if cards.match Pattern
+    end
+    
+    def name
+      'three of a kind'
+    end
+    
+    def base_score
+      3
+    end
+    
+    def relative_score
+      @cards[ Pattern, 1 ].to_i
+    end
+  end
+  
+  class TwoPair < PlayerHand
+    Pattern = /(\d{1,2})[scdh] \1[scdh].*(\d{1,2})[scdh] \2[scdh]/
+    
+    def self.create(cards)
+      new(cards) if cards.match Pattern
+    end
+    
+    def name
+      'two pair'
+    end
+    
+    def base_score
+      2 
+    end
+    
+    def relative_score
+      @cards[ Pattern , 2 ].to_i * 2
+    end
+    
+    def remaining_cards
+      @cards.gsub(Pattern, '').gsub /\D/, ''
+    end
+  end
+  
+  class OnePair < PlayerHand
+    Pattern = /(\d{1,2})[scdh] (?:\s\1[scdh]){1}/x
+    
+    def self.create(cards)
+      new(cards) if cards.match Pattern
+    end
+    
+    def name
+      'one pair'
+    end
+    
+    def base_score
+      1
+    end
+    
+    def relative_score
+      @cards[ Pattern , 1 ].to_i * 2
+    end
+    
+    def remaining_cards
+      @cards.gsub(Pattern, '').gsub /\D/, ''
+    end
+  end
+  
+  class HighCard < PlayerHand
+    def self.create(cards)
+      new(cards)
+    end
+    
+    def name
+      'high card'
+    end
+    
+    def base_score
+      0
+    end
+    
+    def relative_score
+      0
+    end
+  end
+end

data/lib/texas_holdem.rb

@@ -1,8 +1,4 @@
 module TexasHoldem
-  require 'game'
-  require 'hand'
-  require 'player'
-  require 'deck'
-  require 'betting_round'
-  require 'players_hand'
+  ClassFiles = Dir.entries( File.join( File.dirname(__FILE__), '..', 'lib' ) ).grep(/\.rb$/)
+  ClassFiles.each {|klass| require klass.gsub /\.rb/, ''} 
 end

data/test/helper.rb

@@ -20,12 +20,13 @@ class String
   include Test::Unit::Assertions
   
   def hand_name(name)
-    assert_equal name, TexasHoldem::PlayersHand.new(self).name
+    hand = TexasHoldem::PlayerHand.create(self)
+    assert_equal name, hand.name, "\n#{hand.cards} not recognised as a #{name}\n"
   end
   
   def beats(loser)
-    winner, loser = TexasHoldem::PlayersHand.new(self), TexasHoldem::PlayersHand.new(loser)
-    assert( winner > loser )
+    winner, loser = TexasHoldem::PlayerHand.create(self), TexasHoldem::PlayerHand.create(loser)
+    assert winner > loser, "\n #{winner.name} (#{winner.score}) should beat #{loser.name} (#{loser.score})\n"
   end
 end
 

data/test/{test_players_hand.rb → test_player_hand.rb}

@@ -2,14 +2,12 @@ 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')
+    hand = TexasHoldem::PlayerHand.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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: texas_holdem
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Keith McDonnell
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-29 00:00:00 +01:00
+date: 2010-11-05 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -27,7 +27,6 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README
 - README.rdoc
 files: 
 - .autotest
@@ -35,7 +34,6 @@ files:
 - .gitignore
 - Gemfile
 - LICENSE
-- README
 - README.rdoc
 - Rakefile
 - VERSION
@@ -44,7 +42,7 @@ files:
 - lib/game.rb
 - lib/hand.rb
 - lib/player.rb
-- lib/players_hand.rb
+- lib/player_hand.rb
 - lib/texas_holdem.rb
 - test/helper.rb
 - test/test_betting_round.rb
@@ -52,7 +50,7 @@ files:
 - test/test_game.rb
 - test/test_hand.rb
 - test/test_player.rb
-- test/test_players_hand.rb
+- test/test_player_hand.rb
 - test/test_texas_holdem.rb
 has_rdoc: true
 homepage: http://github.com/kmcd/texas_holdem
@@ -91,9 +89,9 @@ summary: Ruby classes modelling a game Texas Holdem poker
 test_files: 
 - test/test_game.rb
 - test/test_player.rb
+- test/test_player_hand.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

data/lib/players_hand.rb

@@ -1,132 +0,0 @@
-# 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