ruby-poker 0.2.0 → 0.2.1

data/CHANGELOG

@@ -13,4 +13,7 @@
     * Added support for hands with >5 cards
     * Straights with a low Ace count now
     * to_s on a PokerHand now includes the rank after the card list
-    * Finally wrote the Unit Tests suite
+    * Finally wrote the Unit Tests suite
+2008-02-08 (0.2.1)
+    * Cards can be added to a hand after it is created by using (<<) on a PokerHand
+    * Cards can be deleted from a hand with PokerHand.delete()

data/README

@@ -2,7 +2,7 @@
 
 == Author
 
-Robert Olson mailto:rko618 [at] gmail.com
+Robert Olson (rko618 [at] gmail [dot] com)
 
 == License
 
@@ -21,7 +21,8 @@ The homepage of this project is located at
 
 == Description
 
-Ruby-Poker handles the logic for poker hands.
+Ruby-Poker handles the logic for getting the rank of a poker hand. It can also be used
+to compare two or more hands to determine which hand has the highest poker value.
 
 Card representations can be passed to the PokerHand constructor as a string or an array.
 Face cards (cards ten, jack, queen, king, and ace) are created using their 
@@ -42,7 +43,6 @@ In this section some examples show what can be done with this class.
 
 == Background
 
-I (Robert Olson) wrote all of the code in the original version of ruby-poker which only
-allowed for hands of 5 cards. I later discovered the amazing poker solving code written by
-Patrick Hurley for http://rubyquiz.com/quiz24.html and merged it into
-ruby-poker 0.2.0.
+I (Robert Olson) wrote all of the code in the original version of ruby-poker which limited
+hands to only 5 cards. As of the 0.2.0 release ruby-poker is based on Patrick Hurley's
+Texas Holdem code from http://rubyquiz.com/quiz24.html which I merged into ruby-poker.

data/lib/card.rb

@@ -58,12 +58,20 @@ class Card
     build_from_value((face - 1) + (suit * FACES.size()))
   end
   
+  # Constructs this card object from another card object
+  def build_from_card(card)
+    @value = card.value
+    @suit = card.suit
+    @face = card.face
+  end
+  
   public
 
-  # got a little carried away with this constructor ;-)
   def initialize(*value)
     if (value.size == 1)
-      if (value[0].respond_to?(:to_str))
+      if (value[0].respond_to?(:to_card))
+        build_from_card(value[0])
+      elsif (value[0].respond_to?(:to_str))
         build_from_string(value[0])
       elsif (value[0].respond_to?(:to_int))
         build_from_value(value[0])
@@ -82,10 +90,22 @@ class Card
   attr_reader :suit, :face, :value
   include Comparable
 
+  # Returns a string containing the representation of Card
+  #
+  # Card.new("7c").to_s                   # => "7c"
   def to_s
     FACES[@face].chr + SUITS[@suit].chr
   end
-
+  
+  # If to_card is called on a `Card` it should return itself
+  def to_card
+    self
+  end
+  
+  # Compare the face value of this card with another card. Returns:
+  # -1 if self is less than card2
+  # 0 if self is the same face value of card2
+  # 1 if self is greater than card2
   def <=> card2
     @face <=> card2.face
   end

data/lib/ruby-poker.rb

@@ -4,9 +4,20 @@ class PokerHand
   include Comparable
   attr_reader :hand
   
+  # Returns a new PokerHand object. Accepts the cards represented
+  # in a string or an array
+  #
+  #     PokerHand.new("3d 5c 8h Ks")   # => #<PokerHand:0x5c673c ...
+  #     PokerHand.new(["3d", "5c", "8h", "Ks"])  # => #<PokerHand:0x5c2d6c ...
   def initialize(cards = [])
     if cards.is_a? Array
-      @hand = cards.map { |str| Card.new(str.to_s) }
+      @hand = cards.map do |card|
+        if card.is_a? Card
+          card
+        else
+          Card.new(card.to_s)
+        end
+      end
     elsif cards.respond_to?(:to_str)
       @hand = cards.scan(/\S{2,3}/).map { |str| Card.new(str) }
     else
@@ -14,20 +25,40 @@ class PokerHand
     end
   end
 
-  def face_values
-    @hand.map { |c| c.face }
-  end
-
+  # Returns a new PokerHand object with the cards sorted by suit
+  # The suit order is spades, hearts, diamonds, clubs
+  #
+  #     PokerHand.new("3d 5c 8h Ks").by_suit.just_cards   # => "Ks 8h 3d 5c"
   def by_suit
     PokerHand.new(@hand.sort_by { |c| [c.suit, c.face] }.reverse)
   end
 
+  # Returns a new PokerHand object with the cards sorted by value
+  # with the highest value first.
+  #
+  #     PokerHand.new("3d 5c 8h Ks").by_face.just_cards   # => "Ks 8h 5c 3d"
   def by_face
     PokerHand.new(@hand.sort_by { |c| [c.face, c.suit] }.reverse)
   end
+  
+  # Returns string representation of the hand without the rank
+  #
+  #     PokerHand.new(["3c", "Kh"]).just_cards     # => "3c Kh"
+  def just_cards
+    @hand.join(" ")
+  end
+  
+  # Returns an array of the card values in the hand.
+  # The values returned are 1 less than the value on the card.
+  # For example: 2's will be shown as 1.
+  #
+  #     PokerHand.new(["3c", "Kh"]).face_values     # => [2, 12]
+  def face_values
+    @hand.map { |c| c.face }
+  end
 
   def =~ (re)
-    re.match(@hand.join(' '))
+    re.match(just_cards)
   end
 
   def royal_flush?
@@ -192,6 +223,9 @@ class PokerHand
     ['Highest Card',    :highest_card? ],
   ]
 
+  # Returns the verbose hand rating
+  #
+  #     PokerHand.new("4s 5h 6c 7d 8s").hand_rating     # => "Straight"
   def hand_rating
     OPS.map { |op|
       (method(op[1]).call()) ? op[0] : false
@@ -199,7 +233,7 @@ class PokerHand
   end
   
   alias :rank :hand_rating
-
+  
   def score
     OPS.map { |op|
       method(op[1]).call()
@@ -209,19 +243,59 @@ class PokerHand
   def arranged_hand
     score[1] + " (#{hand_rating})"
   end
-
-  def just_cards
-    @hand.join(" ")
-  end
   
+  # Returns string with a listing of the cards in the hand followed by the hand's rank.
+  #
+  #     h = PokerHand.new("8c 8s")
+  #     h.to_s                      # => "8c 8s (Pair)"
   def to_s
     just_cards + " (" + hand_rating + ")"
   end
   
+  # Returns an array of `Card` objects that make up the `PokerHand`.
+  def to_a
+    @hand
+  end
+  
+  alias :to_ary :to_a
+  
   def <=> other_hand
     self.score <=> other_hand.score
   end
   
+  # Add a card to the hand
+  # 
+  #     hand = PokerHand.new("5d")
+  #     hand << "6s"          # => Add a six of spades to the hand by passing a string
+  #     hand << ["7h", "8d"]  # => Add multiple cards to the hand using an array
+  def << new_cards
+    # If they only passed one card we need to place it in an array for processing
+    new_cards = [new_cards] if new_cards.is_a?(Card)
+    
+    # luckily .each behaves nicely regardless of whether new_cards is a string or array
+    new_cards.each do |nc|
+      @hand << Card.new(nc)
+    end
+  end
+  
+  # Remove a card from the hand.
+  #
+  #     hand = PokerHand.new("5d Jd")
+  #     hand.delete("Jd")           # => #<Card:0x5d0674 @value=23, @face=10, @suit=1>
+  #     hand.just_cards             # => "5d"
+  def delete card
+    @hand.delete(Card.new(card))
+  end
+  
+  RESOLVING_METHODS = ['size', '+', '-']
+  RESOLVING_METHODS.each do |method|
+    class_eval %{
+      def #{method}(*args, &block)
+        @hand.#{method}(*args, &block)
+      end
+    }
+  end
+  
   protected
   
   def arrange_hand(md)

data/test/test_card.rb

@@ -14,6 +14,12 @@ class TestCard < Test::Unit::TestCase
     @c4 = Card.new("qS")
   end
   
+  def test_build_from_card
+    c1 = Card.new("2c")
+    c2 = Card.new(c1)
+    assert_equal("2c", c2.to_s)
+  end
+  
   def test_class_face_value
     assert_equal(0, Card.face_value('L'))
     assert_equal(13, Card.face_value('A'))

data/test/test_poker_hand.rb

@@ -102,11 +102,32 @@ class TestPokerHand < Test::Unit::TestCase
     assert !PokerHand.new("6D 7C 5D 5H 3S").two_pair?
   end
   
+  def test_matching
+    assert_match(/9c/, @trips)
+  end
+  
+  def test_size
+    assert_equal(2, PokerHand.new("2c 3d").size)
+  end
+  
   def test_comparisons
     assert_equal(0, @trips <=> @trips)
-    assert_equal(1, PokerHand.new("5C JC 2H 5S 3D") <=> PokerHand.new("6D 7C 5D 5H 3S"))
-    assert_equal(-1, PokerHand.new("6D 7C 5D 5H 3S") <=> PokerHand.new("5C JC 2H 5S 3D"))
+    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
+  
+  def test_appending
+    ph = PokerHand.new()
+    ph << "Qd"
+    assert_equal("Qd", ph.just_cards)
+  end
+  
+  def test_delete
+    ph = PokerHand.new("Ac")
+    ph.delete("Ac")
+    assert_equal(Array.new, ph.hand)
   end
 end
 
-# Number of errors detected: 20

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-poker
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Robert Olson
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-21 00:00:00 -08:00
+date: 2008-02-08 00:00:00 -08:00
 default_executable: 
 dependencies: []