ruby-poker 0.3.2 → 1.0.0

data/ruby-poker.gemspec

@@ -1,32 +1,30 @@
 Gem::Specification.new do |s|
   s.name     = "ruby-poker"
-  s.version  = "0.3.1"
-  s.date     = "2009-01-24"
-  s.rubyforge_project = "rubypoker"
+  s.version  = "1.0.0"
   s.platform = Gem::Platform::RUBY
-  s.summary = "Poker library in Ruby"
+  s.summary  = "Poker library in Ruby"
   s.description = "Ruby library for comparing poker hands and determining the winner."
-  s.author  = "Rob Olson"
-  s.email    = "rko618@gmail.com"
-  s.homepage = "http://github.com/robolson/ruby-poker"
-  s.has_rdoc = true
+  s.author   = "Rob Olson"
+  s.email    = "rob@thinkingdigitally.com"
+  s.homepage = "https://github.com/robolson/ruby-poker"
+  s.license  = 'BSD'
   s.files    = ["CHANGELOG", 
-		"examples/deck.rb", 
-		"examples/quick_example.rb", 
-		"lib/card.rb", 
-		"lib/ruby-poker.rb", 
-		"LICENSE", 
-		"Rakefile", 
-		"README.rdoc", 
-		"ruby-poker.gemspec"]
-  s.test_files = ["test/test_card.rb", 
-    "test/test_poker_hand.rb"]
+                "examples/deck.rb", 
+                "examples/quick_example.rb", 
+                "lib/ruby-poker.rb",
+                "lib/ruby-poker/card.rb", 
+                "lib/ruby-poker/poker_hand.rb", 
+                "LICENSE", 
+                "Rakefile", 
+                "README.rdoc", 
+                "ruby-poker.gemspec"]
+  s.test_files = ["test/test_helper.rb", "test/test_card.rb", "test/test_poker_hand.rb"]
   s.require_paths << 'lib'
-  
-  s.extra_rdoc_files = ["README", "CHANGELOG", "LICENSE"]
+
+  s.extra_rdoc_files = ["README.rdoc", "CHANGELOG", "LICENSE"]
   s.rdoc_options << '--title' << 'Ruby Poker Documentation' <<
                     '--main'  << 'README.rdoc' <<
                     '--inline-source' << '-q'
-  
-  # s.add_dependency("thoughtbot-shoulda", ["> 2.0.0"])
+
+  s.add_development_dependency('shoulda-context', '~> 1.1')
 end

data/test/test_card.rb

@@ -7,29 +7,65 @@ class TestCard < Test::Unit::TestCase
     @c2 = Card.new("TD")
     @c3 = Card.new("jh")
     @c4 = Card.new("qS")
+    @c5 = Card.new("AC")
   end
-  
-  def test_build_from_card
-    assert_equal("9c", Card.new(@c1).to_s)
-  end
-  
+
   def test_class_face_value
-    assert_nil(Card.face_value('L'))
+    assert_equal(0,  Card.face_value('L'))
     assert_equal(13, Card.face_value('A'))
   end
 
+  def test_build_from_card
+    assert_equal("9c", Card.new(@c1).to_s)
+  end
+
   def test_build_from_value
-    assert_equal(@c1, Card.new(7))
+    assert_equal(@c1, Card.new(8))
     assert_equal(@c2, Card.new(22))
-    assert_equal(@c3, Card.new(37))
-    assert_equal(@c4, Card.new(52))
+    assert_equal(@c3, Card.new(36))
+    assert_equal(@c4, Card.new(50))
+    assert_equal(@c5, Card.new(13))
+  end
+
+  def test_build_from_face_suit
+    assert_equal(8, Card.new('9', 'c').value)
+    assert_equal(22, Card.new('T', 'd').value)
+    assert_equal(36, Card.new('J', 'h').value)
+    assert_equal(50, Card.new('Q', 's').value)
+    assert_equal(13, Card.new('A', 'c').value)
+  end
+
+  def test_build_from_value_and_from_face_suit_match
+    ticker = 0
+    Card::SUITS.each_char do |suit|
+      "23456789TJQKA".each_char do |face|
+        ticker += 1
+        from_value = Card.new(ticker)
+        from_face_suit = Card.new(face, suit)
+        assert_equal(from_face_suit, from_value,
+                     "Face and suit #{face + suit} did not match card from value #{ticker}")
+      end
+    end
+  end
+
+  def test_build_from_value_and_from_face_suit_values_match
+    ticker = 0
+    0.upto(3) do |suit|
+      1.upto(13) do |face|
+        ticker += 1
+        from_value = Card.new(ticker)
+        from_face_suit_values = Card.new(face, suit)
+        assert_equal(from_face_suit_values, from_value,
+                     "Face=#{face} and suit=#{suit} did not match card from value #{ticker}")
+      end
+    end
   end
 
   def test_face
     assert_equal(8, @c1.face)
     assert_equal(9, @c2.face)
     assert_equal(10, @c3.face)
-    assert_equal(11, @c4.face)          
+    assert_equal(11, @c4.face)
   end
 
   def test_suit
@@ -40,12 +76,13 @@ class TestCard < Test::Unit::TestCase
   end
 
   def test_value
-    assert_equal(7, @c1.value)
+    assert_equal(8, @c1.value)
     assert_equal(22, @c2.value)
-    assert_equal(37, @c3.value)
-    assert_equal(52, @c4.value)
+    assert_equal(36, @c3.value)
+    assert_equal(50, @c4.value)
+    assert_equal(13, @c5.value)
   end
-  
+
   def test_natural_value
     assert_equal(1, Card.new("AC").natural_value)
     assert_equal(15, Card.new("2D").natural_value)
@@ -56,14 +93,10 @@ class TestCard < Test::Unit::TestCase
     assert(@c1 < @c2)
     assert(@c3 > @c2)
   end
-  
+
   def test_equals
     c = Card.new("9h")
     assert_not_equal(@c1, c)
     assert_equal(@c1, @c1)
   end
-  
-  def test_hash
-    assert_equal(15, @c1.hash)
-  end
-end
+end

data/test/test_helper.rb

@@ -1,7 +1,6 @@
 require 'rubygems'
+require 'bundler/setup'
 require 'test/unit'
-require 'shoulda'
+require 'shoulda-context'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'ruby-poker'
+require 'ruby-poker'

data/test/test_poker_hand.rb

@@ -2,22 +2,62 @@ require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
 class TestPokerHand < Test::Unit::TestCase
   context "A PokerHand instance" do
-  
+
     setup do
-      @trips = PokerHand.new("2D 9C AS AH AC")
+      @quads = PokerHand.new('Kc Kh Kd Ks Qs')
       @full_boat = PokerHand.new(["2H", "2D", "4C", "4D", "4S"])
       @flush = PokerHand.new("3D 6D 7D TD QD 5H 2S")
       @straight = PokerHand.new("8H 9D TS JH QC AS")
+      @trips = PokerHand.new("2D 9C AS AH AC")
+      @two_pair = PokerHand.new("As Ac Kc Kd 2s")
+      @pair = PokerHand.new("As Ac Kc Qd 2s")
+      @ace_high = PokerHand.new("As Jh 9c 7d 5s")
+    end
+
+    should "handle empty hands" do
+      assert_equal(PokerHand.new.rank, "Empty Hand")
+    end
+
+    should "handle single card hands" do
+      assert_equal(PokerHand.new('As').rank, @ace_high.rank)
+    end
+
+    should "handle two card hands" do
+      assert_equal(PokerHand.new('As Ac').rank, @pair.rank)
+    end
+
+    should "handle three card hands" do
+      assert_equal(PokerHand.new('As Ac Ah').rank, @trips.rank)
+    end
+
+    should "handle four card hands" do
+      assert_equal(PokerHand.new('As Ac Kd Kh').rank, @two_pair.rank)
+      assert_equal(PokerHand.new('As Ac Ad Ah').rank, @quads.rank)
+    end
+
+    should "handle lower case face card names" do
+      assert_equal(0, PokerHand.new('kc kd') <=> PokerHand.new('Kc Kd'))
+      assert_equal(0, PokerHand.new('kc kd') <=> PokerHand.new('Kc KD'))
+    end
+
+    should "handle hands without space" do
+      assert_equal(0, PokerHand.new('KcKd') <=> PokerHand.new('Kc Kd'))
+      assert_equal(0, PokerHand.new('KcKd9d') <=> PokerHand.new('Kc Kd 9d'))
+    end
+
+    should "raise a clear error with invalid cards" do
+      e = assert_raises(ArgumentError) { PokerHand.new('Fc') }
+      assert_match(/"Fc"/, e.message)
+      e = assert_raises(ArgumentError) { PokerHand.new('Tp') }
+      assert_match(/"Tp"/, e.message)
     end
-  
-    # there are a lot of combinations that should be tested here. I will add more
-    # troublesome cases as I think of them.
+
     should "sort using rank" do
       assert_equal("As Ah Ac 9c 2d", @trips.sort_using_rank)
       assert_equal("4s 4d 4c 2h 2d", @full_boat.sort_using_rank)
       assert_equal("Qd Td 7d 6d 3d 2s 5h", @flush.sort_using_rank)
       assert_equal("Qc Jh Ts 9d 8h As", @straight.sort_using_rank)
-    
+
       assert_equal("As Ah 3d 3c Kd", PokerHand.new("AS AH KD 3D 3C").sort_using_rank)
       assert_equal("As Ah 3d 3c 2d", PokerHand.new("2D AS AH 3D 3C").sort_using_rank)
     end
@@ -33,13 +73,13 @@ class TestPokerHand < Test::Unit::TestCase
     should "return just the face values of the cards" do
       assert_equal([1, 8, 13, 13, 13], @trips.face_values)
     end
-    
+
     should "recognize a straight flush" do
       assert !@flush.straight_flush?
       assert !@straight.straight_flush?
       assert PokerHand.new("8H 9H TH JH QH AS").straight_flush?
     end
-  
+
     should "recognize a royal flush" do
       assert !@flush.royal_flush?
       assert PokerHand.new("AD KD QD JD TD").royal_flush?
@@ -59,10 +99,13 @@ class TestPokerHand < Test::Unit::TestCase
       assert !@trips.full_house?
       assert @full_boat.full_house?
     end
-    
+
     should "recognize a straight" do
       assert @straight.straight?
+      # ace low straight
       assert PokerHand.new("AH 2S 3D 4H 5D").straight?
+      # ace high straight
+      assert PokerHand.new("AH KS QD JH TD").straight?
     end
 
     should "recognize a three of a kind" do
@@ -73,12 +116,12 @@ class TestPokerHand < Test::Unit::TestCase
       assert PokerHand.new("2S 2D TH TD 4S").two_pair?
       assert !PokerHand.new("6D 7C 5D 5H 3S").two_pair?
     end
-    
+
     should "recognize a pair" do
       assert !PokerHand.new("5C JC 2H 7S 3D").pair?
       assert PokerHand.new("6D 7C 5D 5H 3S").pair?
     end
-    
+
     should "recognize a hand with the rank highest_card" do
       # hard to test, make sure it does not return null
       assert PokerHand.new("2D 4S 6C 8C TH").highest_card?
@@ -110,42 +153,42 @@ class TestPokerHand < Test::Unit::TestCase
       assert_match(/9c/, @trips.to_s)
       assert_no_match(/AD/, @trips.to_s)
     end
-  
+
     should "return the correct number of cards in the hand" do
       assert_equal(0, PokerHand.new.size)
       assert_equal(1, PokerHand.new("2c").size)
       assert_equal(2, PokerHand.new("2c 3d").size)
     end
-  
+
     should "be comparable to other PokerHands" do
       hand1 = PokerHand.new("5C JC 2H 5S 3D")
       hand2 = PokerHand.new("6D 7C 5D 5H 3S")
       assert_equal(1, hand1 <=> hand2)
       assert_equal(-1, hand2 <=> hand1)
     end
-  
+
     should "be considered equal to other poker hands that contain the same cards" do
       assert_equal(0, @trips <=> @trips)
-    
+
       hand1 = PokerHand.new("Ac Qc Ks Kd 9d 3c")
       hand2 = PokerHand.new("Ah Qs 9h Kh Kc 3s")
       assert_equal(0, hand1 <=> hand2)
     end
-  
-    should "be able to add a Card to itself" do
+
+    should "be able to insert new cards into the hand" do
       ph = PokerHand.new()
       ph << "Qd"
       ph << Card.new("2D")
       ph << ["3d", "4d"]
       assert_equal("Qd 2d 3d 4d", ph.just_cards)
     end
-  
+
     should "be able to delete a card" do
       ph = PokerHand.new("Ac")
       ph.delete("Ac")
       assert_equal(Array.new, ph.hand)
     end
-    
+
     should "detect the two highest pairs when there are more than two" do
       ph = PokerHand.new("7d 7s 4d 4c 2h 2d")
       assert_equal([3, 6, 3, 1], ph.two_pair?[0])
@@ -155,66 +198,333 @@ class TestPokerHand < Test::Unit::TestCase
       # 3: second highest pair is two 4's
       # 1: kicker is a 2
     end
-  
+
     context "when duplicates are allowed" do
       setup do
         PokerHand.allow_duplicates = true
       end
-    
+
       should "create a PokerHand of unique cards" do
         uniq_ph = PokerHand.new("3s 4s 3s").uniq
         assert_instance_of(PokerHand, uniq_ph)  # want to be sure uniq hands back a PokerHand
         assert_contains(uniq_ph.hand, Card.new('3s'))
         assert_contains(uniq_ph.hand, Card.new('4s'))
       end
-    
+
       should "allow five of a kind" do
         # there is no five of a kind. This just tests to make sure
         # that ruby-poker doesn't crash if given 5 of the same card
         ph = PokerHand.new("KS KS KS KS KS")
         assert_equal("Four of a kind", ph.rank)
       end
-  
+
       should "allow duplicates on initialize" do
         assert_nothing_raised RuntimeError do
           PokerHand.new("3s 3s")
         end
       end
-    
+
       should "allow duplicate card to be added after initialize" do
         ph = PokerHand.new("2d")
         ph << "2d"
         assert_equal("2d 2d", ph.just_cards)
       end
     end
-  
+
     context "when duplicates are not allowed" do
       setup do
         PokerHand.allow_duplicates = false
       end
-  
+
       should "not allow duplicates on initialize" do
         PokerHand.allow_duplicates = false
-    
+
         assert_raise RuntimeError do
           PokerHand.new("3s 3s")
         end
-    
+
         PokerHand.allow_duplicates = true
       end
-    
+
       should "not allow duplicates after initialize" do
         PokerHand.allow_duplicates = false
-    
-        ph = PokerHand.new("2d")    
+
+        ph = PokerHand.new("2d")
         assert_raise RuntimeError do
           ph << "2d"
         end
-    
+
         PokerHand.allow_duplicates = true
       end
     end
-    
+
+    should "have an each method" do
+      cards = []
+      @straight.each do |card|
+        cards << card
+      end
+      assert_equal @straight.to_a, cards
+    end
+
+    should "be Enumerable" do
+      assert PokerHand.include?(Enumerable)
+    end
   end
-end
 
+  context "addition" do
+    setup do
+      @base = PokerHand.new('Ac Kc')
+    end
+
+    should "work with a string" do
+      assert_equal PokerHand.new('Ac Kc Qc'), @base + 'Qc'
+    end
+
+    should "work with a card" do
+      assert_equal PokerHand.new('Ac Kc Qc'), @base + Card.new('Qc')
+    end
+
+    should "work with a hand" do
+      assert_equal PokerHand.new('Ac Kc Qc'), @base + PokerHand.new('Qc')
+    end
+
+    should "not modify the receiver hand" do
+      result = @base + 'Qc'
+      assert_not_equal result, @base
+    end
+
+    should "not affect receiver cards" do
+      result = @base + 'Qc'
+      result.to_a.first.instance_eval { @face = Card.face_value('2') }
+      assert_equal PokerHand.new('Ac Kc'), @base
+    end
+  end
+
+  context "PokerHand#pair?" do
+
+    should "return false with one card" do
+      assert !PokerHand.new("2h").pair?
+    end
+
+    context "with a pair" do
+
+      should "return 2, followed by the pair value" do
+        assert_equal [2, 5-1], PokerHand.new("5h 5s").pair?[0]
+      end
+
+      context "with a two card hand" do
+        setup do
+          @ph = PokerHand.new("5h 5s")
+          @scoring = @ph.pair?[0]
+        end
+
+        should "return scoring with 2 entries" do
+          assert_equal 2, @scoring.size
+        end
+      end
+
+      context "with a three card hand" do
+        setup do
+          @ph = PokerHand.new("5h 5s 8s")
+          @scoring = @ph.pair?[0]
+        end
+
+        should "return scoring with 3 entries" do
+          assert_equal 3, @scoring.size
+        end
+
+        should "return the value of the kicker" do
+          assert_equal 8-1, @scoring[2]
+        end
+      end
+
+      context "with a four card hand" do
+        setup do
+          @ph = PokerHand.new("5h 5s 8s 7s")
+          @scoring = @ph.pair?[0]
+        end
+
+        should "return scoring with 4 entries" do
+          assert_equal 4, @scoring.size
+        end
+
+        should "return the values of the kickers" do
+          assert_equal 8-1, @scoring[2]
+          assert_equal 7-1, @scoring[3]
+        end
+      end
+
+      context "with a five (or more) card hand" do
+        setup do
+          @ph = PokerHand.new("5h 5s 8s 7s 6s 2h")
+          @scoring = @ph.pair?[0]
+        end
+
+        should "return scoring with 5 entries" do
+          assert_equal 5, @scoring.size
+        end
+
+        should "return the values of the kickers" do
+          assert_equal 8-1, @scoring[2]
+          assert_equal 7-1, @scoring[3]
+          assert_equal 6-1, @scoring[4]
+        end
+      end
+    end
+
+    context "without a pair" do
+      should "return false" do
+        assert !PokerHand.new("2h 3h").pair?
+      end
+    end
+  end
+
+
+  def assert_hand_match(expression, cards)
+    hand = PokerHand.new(cards)
+    assert hand.match?(expression), "#{cards} didn't match #{expression}"
+  end
+
+  def assert_hand_not_match(expression, cards)
+    hand = PokerHand.new(cards)
+    assert !hand.match?(expression), "#{cards} did match #{expression}"
+  end
+
+  context "matching expression" do
+    should "match two faces" do
+      assert_hand_match 'AA', 'Ah Ad'
+      assert_hand_match 'Q8', 'Qc 8d'
+    end
+
+    should "not match two faces" do
+      assert_hand_not_match 'T9', 'Tc 8s'
+      assert_hand_not_match 'QQ', 'Tc 8s'
+    end
+
+    should "match unordered faces" do
+      assert_hand_match 'K7', '7c Ks'
+    end
+
+    should "match suited when suited" do
+      assert_hand_match 'Q8s', 'Qc 8c'
+      assert_hand_match '56s', '5h 6h'
+    end
+
+    should "not match suited when offsuit" do
+      assert_hand_not_match 'Q8s', 'Qc 8d'
+      assert_hand_not_match '56s', '5h 6c'
+    end
+
+    should "match offsuit when offsuited" do
+      assert_hand_match 'Q8o', 'Qc 8h'
+      assert_hand_match '56o', '5h 6s'
+    end
+
+    should "not match offsuit when suited" do
+      assert_hand_not_match 'Q8o', 'Qc 8c'
+      assert_hand_not_match '56o', '5h 6h'
+    end
+
+    should "match pair min" do
+      assert_hand_match 'JJ+', 'Jc Js'
+      assert_hand_match '66+', 'Qc Qh'
+      assert_hand_match 'JJ+', 'Ad Ac'
+    end
+
+    should "not match pair min" do
+      assert_hand_not_match 'JJ+', 'Tc Ts'
+      assert_hand_not_match '66+', 'Qc Kh'
+      assert_hand_not_match 'AA+', '2d 2c'
+    end
+
+    should "match face min" do
+      assert_hand_match 'AJ+', 'Ac Js'
+      assert_hand_match 'AQ+', 'Ac Kc'
+      assert_hand_match 'AJ+', 'Ac As'
+      assert_hand_match 'QT+', 'Qc Ts'
+      assert_hand_match 'QT+', 'Qc Qs'
+      assert_hand_not_match 'QT+', 'Qc Ks' # sure? should be matched with KQ+?
+      assert_hand_not_match 'AJ+', 'Ac Ts'
+      assert_hand_not_match 'AJ+', 'Tc Ts'
+    end
+
+    should "match suited face min" do
+      assert_hand_match 'AJs+', 'Ac Jc'
+      assert_hand_match 'AQs+', 'Ac Kc'
+      assert_hand_not_match 'AJs+', 'Ac As'
+      assert_hand_match 'QTs+', 'Qc Tc'
+      assert_hand_not_match 'QTs+', 'Qc Ts'
+      assert_hand_not_match 'AJs+', 'Ac Qs'
+    end
+
+    should "match offsuit face min" do
+      assert_hand_match 'AJo+', 'Ac Jd'
+      assert_hand_match 'AQo+', 'Ac Kh'
+      assert_hand_match 'AJo+', 'Ac As'
+      assert_hand_match 'QTo+', 'Qc Td'
+      assert_hand_not_match 'QTo+', 'Qc Tc'
+      assert_hand_not_match 'AJo+', 'Ac Qc'
+    end
+
+    should "match face with 1 gap" do
+      assert_hand_match '89+', '8c 9d'
+      assert_hand_match '89+', '9c Td'
+      assert_hand_match '89+', 'Tc Jd'
+      assert_hand_match '89+', 'Ac Kd'
+      assert_hand_not_match '89+', '8c Td'
+      assert_hand_not_match '89+', 'Tc Td'
+      assert_hand_not_match '89+', '7c 8d'
+    end
+
+    should "match face with 2 gaps" do
+      assert_hand_match '8T+', '8c Td'
+      assert_hand_match '8T+', 'Tc 8d'
+      assert_hand_match '24+', '9c Jd'
+      assert_hand_match '79+', 'Ac Qd'
+      assert_hand_not_match '8T+', '8c 9d'
+      assert_hand_not_match '8T+', 'Tc Td'
+      assert_hand_not_match '8T+', 'Jc Ad'
+      assert_hand_not_match '8T+', '7c 9d'
+    end
+
+    should "match face with many gaps" do
+      assert_hand_match '8J+', '9c Qd'
+      assert_hand_match '8Q+', '9c Kd'
+      assert_hand_match '8K+', 'Ac 9d'
+      assert_hand_not_match '8J+', '7c Td'
+    end
+
+    should "match face gap with suit" do
+      assert_hand_match '89s+', '9c Tc'
+      assert_hand_not_match '89s+', '9c Td'
+      assert_hand_match '89o+', '9c Th'
+      assert_hand_not_match '89o+', '9d Td'
+    end
+
+    [
+      %w(),
+      %w(Ac),
+      %w(Ac Kc Qc),
+      %w(Ac Kc Qc Jc Tc),
+    ].each do |cards|
+      should "raise an error if the number of cards is #{cards.size}" do
+        hand = PokerHand.new(cards)
+        assert_raises RuntimeError do
+          hand.match?('AA')
+        end
+      end
+    end
+
+    should "raise an error with invalid expression" do
+      hand = PokerHand.new("Ac Kc")
+      assert_raises ArgumentError do
+        hand.match? "foo"
+      end
+
+      assert_raises ArgumentError do
+        hand.match? ""
+      end
+    end
+  end
+
+end