ruby-poker 0.3.1 → 0.3.2

data/CHANGELOG

@@ -1,3 +1,9 @@
+2009-07-12 (0.3.2)
+    * Reorganized ruby-poker's lib folder to match the standard layout for gems. This makes ruby-poker compatible with Rip.
+    * Bug [#26276] improper two_pair? behavior. Applied patch by Uro.
+    * Changed protected methods in PokerHand to private
+    * Added natural_value method to Card
+
 2009-01-24 (0.3.1)
     * Bug [#23623] undefined method <=> for nil:NilClass
     
@@ -43,11 +49,3 @@
         
 2008-01-10 (0.1.0)
     * Initial version
-
-
-
-
-
-
-
-    

data/README.rdoc

@@ -1,8 +1,9 @@
 = Poker library in Ruby
+===
 
-== Author
-
-Rob Olson (rko618 [at] gmail)
+Author:: {Rob Olson}[http://thinkingdigitally.com]
+Email:: [first name] [at] thinkingdigitally.com
+GitHub:: http://github.com/robolson/ruby-poker
 
 == Description
 
@@ -14,9 +15,7 @@ Card representations can be passed to the PokerHand constructor as a string or a
 
     sudo gem install ruby-poker
 
-== Examples
-
-In this section some examples show what can be done with this class.
+== Example
 
     require 'rubygems'
     require 'ruby-poker'
@@ -40,11 +39,11 @@ Place that line near the beginning of your program. The change is program wide s
 
 == Compatibility
 
-Ruby-Poker is compatible with Ruby 1.8 and Ruby 1.9.
+Ruby-Poker is compatible with Ruby 1.8.6 and Ruby 1.9.1.
 
 == History
 
-In the 0.2.0 release Patrick Hurley's Texas Holdem code from http://rubyquiz.com/quiz24.html was merged into ruby-poker.
+In the 0.2.0 release Patrick Hurley's Texas Holdem code from http://www.rubyquiz.com/quiz24.html was merged into ruby-poker.
 
 == License
 

data/Rakefile

@@ -1,58 +1,55 @@
-#!/usr/bin/env ruby
-
-require 'rake/rdoctask'
-require "rake/testtask"
-require 'rake/gempackagetask'
+require 'rubygems'
+require 'rake'
 
 begin
-  require "rubygems"
+  require 'metric_fu'
 rescue LoadError
-  nil
 end
 
-RUBYPOKER_VERSION = "0.3.1"
+RUBYPOKER_VERSION = "0.3.2"
 
 spec = Gem::Specification.new do |s|
   s.name     = "ruby-poker"
   s.version  = RUBYPOKER_VERSION
-  s.date     = "2009-01-24"
+  s.date     = "2009-07-27"
   s.rubyforge_project = "rubypoker"
   s.platform = Gem::Platform::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.email    = "rob@thinkingdigitally.com"
   s.homepage = "http://github.com/robolson/ruby-poker"
   s.has_rdoc = true
   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.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('thoughtbot-shoulda', '> 2.0.0')
 end
 
+require 'rake/gempackagetask'
 Rake::GemPackageTask.new(spec) do |pkg| 
   pkg.need_tar = true 
   pkg.need_zip = true
 end
 
-Rake::TestTask.new do |test|
-  test.libs << "test"
-  test.test_files = Dir[ "test/test_*.rb" ]
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
   test.verbose = true
   test.warning = true
 end
@@ -62,10 +59,12 @@ task :autotest do
   ruby "-I lib -w /usr/bin/autotest"
 end
 
+require 'rake/rdoctask'
 Rake::RDocTask.new(:docs) do |rdoc|
-  rdoc.rdoc_files.include('README.rdoc', 'CHANGELOG', 'LICENSE', 'lib/')
   rdoc.main     = 'README.rdoc'
-  rdoc.rdoc_dir = 'doc/html'
-  rdoc.title    = 'Ruby Poker Documentation'
-  rdoc.options << '--inline-source'
-end
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = "Ruby Poker #{RUBYPOKER_VERSION}"
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGELOG', 'LICENSE', 'lib/**/*.rb')
+end
+
+task :default => :test

data/examples/deck.rb

@@ -1,13 +1,5 @@
 # This is a sample Deck implementation.
 class Deck
-  def shuffle
-    deck_size = @cards.size
-    (deck_size * 2).times do
-      pos1, pos2 = rand(deck_size), rand(deck_size)
-      @cards[pos1], @cards[pos2] = @cards[pos2], @cards[pos1]
-    end
-  end
-
   def initialize
     @cards = []
     Card::SUITS.each_byte do |suit|
@@ -16,12 +8,39 @@ class Deck
         @cards.push(Card.new(face.chr, suit.chr))
       end
     end
-    shuffle()
+    shuffle
+  end
+  
+  def shuffle
+    @cards = @cards.sort_by { rand }
+    return self
   end
 
+  # removes a single card from the top of the deck and returns it
+  # synonymous to poping off a stack
   def deal
     @cards.pop
   end
+  
+  # delete an array or a single card from the deck
+  # converts a string to a new card, if a string is given
+  def burn(burn_cards)
+    return false if burn_cards.is_a?(Integer)
+    if burn_cards.is_a?(Card) || burn_cards.is_a?(String)
+      burn_cards = [burn_cards]
+    end
+    
+    burn_cards.map! do |c|
+      c = Card.new(c) unless c.class == Card
+      @cards.delete(c)
+    end
+    true
+  end
+
+  # return count of the remaining cards
+  def size
+    @cards.size
+  end
 
   def empty?
     @cards.empty?

data/lib/ruby-poker.rb

@@ -1,401 +1,3 @@
-require 'card.rb'
-
-class PokerHand
-  include Comparable
-  attr_reader :hand
-  
-  @@allow_duplicates = true    # true by default
-  def self.allow_duplicates; @@allow_duplicates; end
-  def self.allow_duplicates=(v); @@allow_duplicates = v; end
-  
-  # 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 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
-      @hand = cards
-    end
-    
-    check_for_duplicates if !@@allow_duplicates
-  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
-  alias :cards :just_cards
-  
-  # 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
-
-  # The =~ method does a regular expression match on the cards in this hand.
-  # This can be useful for many purposes. A common use is the check if a card
-  # exists in a hand.
-  #
-  #     PokerHand.new("3d 4d 5d") =~ /8h/           # => nil
-  #     PokerHand.new("3d 4d 5d") =~ /4d/           # => #<MatchData:0x615e18>
-  def =~ (re)
-    re.match(just_cards)
-  end
-
-  def royal_flush?
-    if (md = (by_suit =~ /A(.) K\1 Q\1 J\1 T\1/))
-      [[10], arrange_hand(md)]
-    else
-      false
-    end
-  end
-
-  def straight_flush?
-    if (md = (/.(.)(.)(?: 1.\2){4}/.match(delta_transform(true))))
-      high_card = Card::face_value(md[1])
-      arranged_hand = fix_low_ace_display(md[0] + ' ' +
-          md.pre_match + ' ' + md.post_match)
-      [[9, high_card], arranged_hand]
-    else
-      false
-    end
-  end
-
-  def four_of_a_kind?
-    if (md = (by_face =~ /(.). \1. \1. \1./))
-      # get kicker
-      (md.pre_match + md.post_match).match(/(\S)/)
-      [
-        [8, Card::face_value(md[1]), Card::face_value($1)],
-        arrange_hand(md)
-      ]
-    else
-      false
-    end
-  end
-
-  def full_house?
-    if (md = (by_face =~ /(.). \1. \1. (.*)(.). \3./))
-      arranged_hand = arrange_hand(md[0] + ' ' +
-          md.pre_match + ' ' + md[2] + ' ' + md.post_match)
-      [
-        [7, Card::face_value(md[1]), Card::face_value(md[3])],
-        arranged_hand
-      ]
-    elsif (md = (by_face =~ /((.). \2.) (.*)((.). \5. \5.)/))
-      arranged_hand = arrange_hand(md[4] + ' '  + md[1] + ' ' +
-          md.pre_match + ' ' + md[3] + ' ' + md.post_match)
-      [
-        [7, Card::face_value(md[5]), Card::face_value(md[2])],
-        arranged_hand
-      ]
-    else
-      false
-    end
-  end
-
-  def flush?
-    if (md = (by_suit =~ /(.)(.) (.)\2 (.)\2 (.)\2 (.)\2/))
-      [
-        [
-          6,
-          Card::face_value(md[1]),
-          *(md[3..6].map { |f| Card::face_value(f) })
-        ],
-        arrange_hand(md)
-      ]
-    else
-      false
-    end
-  end
-
-  def straight?
-    result = false
-    if hand.size >= 5
-      transform = delta_transform
-      # note we can have more than one delta 0 that we
-      # need to shuffle to the back of the hand
-      i = 0
-      until transform.match(/^\S{3}( [1-9x]\S\S)+( 0\S\S)*$/) or i >= hand.size  do
-        # only do this once per card in the hand to avoid entering an
-        # infinite loop if all of the cards in the hand are the same
-        transform.gsub!(/(\s0\S\S)(.*)/, "\\2\\1")    # moves the front card to the back of the string
-        i += 1
-      end
-      if (md = (/.(.). 1.. 1.. 1.. 1../.match(transform)))
-        high_card = Card::face_value(md[1])
-        arranged_hand = fix_low_ace_display(md[0] + ' ' + md.pre_match + ' ' + md.post_match)
-        result = [[5, high_card], arranged_hand]
-      end
-    end
-  end
-
-  def three_of_a_kind?
-    if (md = (by_face =~ /(.). \1. \1./))
-      # get kicker
-      arranged_hand = arrange_hand(md)
-      arranged_hand.match(/(?:\S\S ){3}(\S)\S (\S)/)
-      [
-        [
-          4,
-          Card::face_value(md[1]),
-          Card::face_value($1),
-          Card::face_value($2)
-        ],
-        arranged_hand
-      ]
-    else
-      false
-    end
-  end
-
-  def two_pair?
-    # \1 is the face value of the first pair
-    # \2 is the card in between the first pair and the second pair
-    # \3 is the face value of the second pair
-    if (md = (by_face =~ /(.). \1.(.*) (.). \3./))
-      # to get the kicker this does the following
-      # md[0] is the regex matched above which includes the first pair and
-      # the second pair but also some cards in the middle so we sub them out
-      # then we add on the cards that came before the first pair, the cards that
-      # we in between, and the cards that came after.
-      arranged_hand = arrange_hand(md[0].sub(md[2], '') + ' ' +
-          md.pre_match + ' ' + md[2] + ' ' + md.post_match)
-      arranged_hand.match(/(?:\S\S ){4}(\S)/)
-      [
-        [
-          3,
-          Card::face_value(md[1]),    # face value of the first pair
-          Card::face_value(md[3]),    # face value of the second pair
-          Card::face_value($1)        # face value of the kicker
-        ],
-        arranged_hand
-      ]
-    else
-      false
-    end
-  end
-
-  def pair?
-    if (md = (by_face =~ /(.). \1./))
-      # get kicker
-      arranged_hand = arrange_hand(md)
-      arranged_hand.match(/(?:\S\S ){2}(\S)\S\s+(\S)\S\s+(\S)/)
-      [
-        [
-          2,
-          Card::face_value(md[1]),
-          Card::face_value($1),
-          Card::face_value($2),
-          Card::face_value($3)
-        ],
-        arranged_hand
-      ]
-    else
-      false
-    end
-  end
-
-  def highest_card?
-    result = by_face
-    [[1, *result.face_values[0..4]], result.hand.join(' ')]
-  end
-
-  OPS = [
-    ['Royal Flush',     :royal_flush? ],
-    ['Straight Flush',  :straight_flush? ],
-    ['Four of a kind',  :four_of_a_kind? ],
-    ['Full house',      :full_house? ],
-    ['Flush',           :flush? ],
-    ['Straight',        :straight? ],
-    ['Three of a kind', :three_of_a_kind?],
-    ['Two pair',        :two_pair? ],
-    ['Pair',            :pair? ],
-    ['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
-    }.find { |v| v }
-  end
-  
-  alias :rank :hand_rating
-  
-  def score
-    OPS.map { |op|
-      method(op[1]).call()
-    }.find([0]) { |score| score }
-  end
-
-  # Returns a string of the hand arranged based on its rank. Usually this will be the
-  # same as by_face but there are some cases where it makes a difference.
-  #
-  #     ph = PokerHand.new("AS 3S 5S 2S 4S")
-  #     ph.sort_using_rank        # => "5s 4s 3s 2s As"
-  #     ph.by_face.just_cards       # => "As 5s 4s 3s 2s"   
-  def sort_using_rank
-    score[1]
-  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[0].compact <=> other_hand.score[0].compact
-  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 new_cards.is_a?(Card) || new_cards.is_a?(String)
-      new_cards = [new_cards]
-    end
-    
-    new_cards.each do |nc|
-      unless @@allow_duplicates
-        raise "A card with the value #{nc} already exists in this hand. Set PokerHand.allow_duplicates to true if you want to be able to add a card more than once." if self =~ /#{nc}/
-      end
-      
-      @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
-  
-  # Same concept as Array#uniq
-  def uniq
-    PokerHand.new(@hand.uniq)
-  end
-  
-  # Resolving methods are just passed directly down to the @hand array
-  RESOLVING_METHODS = [:size, :+, :-]
-  RESOLVING_METHODS.each do |method|
-    class_eval %{
-      def #{method}(*args, &block)
-        @hand.#{method}(*args, &block)
-      end
-    }
-  end
-  
-  protected
-  
-  def check_for_duplicates
-    if @hand.size != @hand.uniq.size && !@@allow_duplicates
-      raise "You are attempting to create a hand that contains duplicate cards. Set PokerHand.allow_duplicates to true if you do not want to ignore this error."
-    end
-  end
-  
-  # if md is a string, arrange_hand will remove extra white space
-  # if md is a MatchData, arrange_hand returns the matched segment
-  # followed by the pre_match and the post_match
-  def arrange_hand(md)
-      hand = if (md.respond_to?(:to_str))
-        md
-      else
-        md[0] + ' ' + md.pre_match + md.post_match
-      end
-      hand.strip.squeeze(" ")   # remove extra whitespace
-  end
-  
-  def delta_transform(use_suit = false)
-    aces = @hand.select { |c| c.face == Card::face_value('A') }
-    aces.map! { |c| Card.new(1,c.suit) }
-
-    base = if (use_suit)
-      (@hand + aces).sort_by { |c| [c.suit, c.face] }.reverse
-    else
-      (@hand + aces).sort_by { |c| [c.face, c.suit] }.reverse
-    end
-
-    result = base.inject(['',nil]) do |(delta_hand, prev_card), card|
-      if (prev_card)
-        delta = prev_card - card.face
-      else
-        delta = 0
-      end
-      # does not really matter for my needs
-      delta = 'x' if (delta > 9 || delta < 0)
-      delta_hand += delta.to_s + card.to_s + ' '
-      [delta_hand, card.face]
-    end
-
-    # we just want the delta transform, not the last cards face too
-    result[0].chop
-  end
-
-  def fix_low_ace_display(arranged_hand)
-    # remove card deltas (this routine is only used for straights)
-    arranged_hand.gsub!(/\S(\S\S)\s*/, "\\1 ")
-
-    # Fix "low aces"
-    arranged_hand.gsub!(/L(\S)/, "A\\1")
-
-    # Remove duplicate aces (this will not work if you have
-    # multiple decks or wild cards)
-    arranged_hand.gsub!(/((A\S).*)\2/, "\\1")
-
-    # cleanup white space
-    arranged_hand.gsub!(/\s+/, ' ')
-    # careful to use gsub as gsub! can return nil here
-    arranged_hand.gsub(/\s+$/, '')
-  end
-  
-end
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))   # For use/testing when no gem is installed
+require 'ruby-poker/card'
+require 'ruby-poker/poker_hand'

data/lib/{card.rb → ruby-poker/card.rb}

@@ -5,11 +5,7 @@ class Card
     'c' => 0,
     'd' => 1,
     'h' => 2,
-    's' => 3,
-    'C' => 0,
-    'D' => 1,
-    'H' => 2,
-    'S' => 3,
+    's' => 3
   }
   FACE_VALUES = {
     'L' =>  1,   # this is a magic low ace
@@ -25,23 +21,20 @@ class Card
     'J' => 11,
     'Q' => 12,
     'K' => 13,
-    'A' => 14,
+    'A' => 14
   }
 
   def Card.face_value(face)
-    if (face)
-      FACE_VALUES[face.upcase] - 1
-    else
+    face.upcase!
+    if face == 'L' || !FACE_VALUES.has_key?(face)
       nil
+    else
+      FACE_VALUES[face] - 1
     end
   end
 
-  protected
+  private
   
-  def build_from_string(card)
-    build_from_face_suit(card[0,1], card[1,1])
-  end
-
   def build_from_value(value)
     @value = value
     @suit  = value / FACES.size()
@@ -49,6 +42,7 @@ class Card
   end
 
   def build_from_face_suit(face, suit)
+    suit.downcase!
     @face  = Card::face_value(face)
     @suit  = SUIT_LOOKUP[suit]
     @value = (@suit * FACES.size()) + (@face - 1)
@@ -58,6 +52,10 @@ class Card
     build_from_value((face - 1) + (suit * FACES.size()))
   end
   
+  def build_from_string(card)
+    build_from_face_suit(card[0,1], card[1,1])
+  end
+  
   # Constructs this card object from another card object
   def build_from_card(card)
     @value = card.value
@@ -122,4 +120,20 @@ class Card
   def hash
     @value.hash
   end
+  
+  # A card's natural value is the closer to it's intuitive value in a deck
+  # in the range of 1 to 52. Aces are low with a value of 1. Uses the bridge
+  # order of suits: clubs, diamonds, hearts, and spades. The formula used is:
+  # If the suit is clubs, the natural value is the face value (remember
+  # Aces are low). If the suit is diamonds, it is the clubs value plus 13.
+  # If the suit is hearts, it is plus 26. If it is spades, it is plus 39.
+  #
+  #     Card.new("Ac").natural_value    # => 1
+  #     Card.new("Kc").natural_value    # => 12
+  #     Card.new("Ad").natural_value    # => 13
+  def natural_value
+    natural_face = @face == 13 ? 1 : @face+1  # flip Ace from 13 to 1 and
+                                              # increment everything else by 1
+    natural_face + @suit * 13
+  end
 end

data/lib/ruby-poker/poker_hand.rb

@@ -0,0 +1,407 @@
+class PokerHand
+  include Comparable
+  attr_reader :hand
+  
+  @@allow_duplicates = true    # true by default
+  def self.allow_duplicates; @@allow_duplicates; end
+  def self.allow_duplicates=(v); @@allow_duplicates = v; end
+  
+  # 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 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
+      @hand = cards
+    end
+    
+    check_for_duplicates if !@@allow_duplicates
+  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
+  alias :cards :just_cards
+  
+  # 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
+
+  # The =~ method does a regular expression match on the cards in this hand.
+  # This can be useful for many purposes. A common use is the check if a card
+  # exists in a hand.
+  #
+  #     PokerHand.new("3d 4d 5d") =~ /8h/           # => nil
+  #     PokerHand.new("3d 4d 5d") =~ /4d/           # => #<MatchData:0x615e18>
+  def =~ (re)
+    re.match(just_cards)
+  end
+
+  def royal_flush?
+    if (md = (by_suit =~ /A(.) K\1 Q\1 J\1 T\1/))
+      [[10], arrange_hand(md)]
+    else
+      false
+    end
+  end
+
+  def straight_flush?
+    if (md = (/.(.)(.)(?: 1.\2){4}/.match(delta_transform(true))))
+      high_card = Card::face_value(md[1])
+      arranged_hand = fix_low_ace_display(md[0] + ' ' +
+          md.pre_match + ' ' + md.post_match)
+      [[9, high_card], arranged_hand]
+    else
+      false
+    end
+  end
+
+  def four_of_a_kind?
+    if (md = (by_face =~ /(.). \1. \1. \1./))
+      # get kicker
+      (md.pre_match + md.post_match).match(/(\S)/)
+      [
+        [8, Card::face_value(md[1]), Card::face_value($1)],
+        arrange_hand(md)
+      ]
+    else
+      false
+    end
+  end
+
+  def full_house?
+    if (md = (by_face =~ /(.). \1. \1. (.*)(.). \3./))
+      arranged_hand = arrange_hand(md[0] + ' ' +
+          md.pre_match + ' ' + md[2] + ' ' + md.post_match)
+      [
+        [7, Card::face_value(md[1]), Card::face_value(md[3])],
+        arranged_hand
+      ]
+    elsif (md = (by_face =~ /((.). \2.) (.*)((.). \5. \5.)/))
+      arranged_hand = arrange_hand(md[4] + ' '  + md[1] + ' ' +
+          md.pre_match + ' ' + md[3] + ' ' + md.post_match)
+      [
+        [7, Card::face_value(md[5]), Card::face_value(md[2])],
+        arranged_hand
+      ]
+    else
+      false
+    end
+  end
+
+  def flush?
+    if (md = (by_suit =~ /(.)(.) (.)\2 (.)\2 (.)\2 (.)\2/))
+      [
+        [
+          6,
+          Card::face_value(md[1]),
+          *(md[3..6].map { |f| Card::face_value(f) })
+        ],
+        arrange_hand(md)
+      ]
+    else
+      false
+    end
+  end
+
+  def straight?
+    result = false
+    if hand.size >= 5
+      transform = delta_transform
+      # note we can have more than one delta 0 that we
+      # need to shuffle to the back of the hand
+      i = 0
+      until transform.match(/^\S{3}( [1-9x]\S\S)+( 0\S\S)*$/) or i >= hand.size  do
+        # only do this once per card in the hand to avoid entering an
+        # infinite loop if all of the cards in the hand are the same
+        transform.gsub!(/(\s0\S\S)(.*)/, "\\2\\1")    # moves the front card to the back of the string
+        i += 1
+      end
+      if (md = (/.(.). 1.. 1.. 1.. 1../.match(transform)))
+        high_card = Card::face_value(md[1])
+        arranged_hand = fix_low_ace_display(md[0] + ' ' + md.pre_match + ' ' + md.post_match)
+        result = [[5, high_card], arranged_hand]
+      end
+    end
+  end
+
+  def three_of_a_kind?
+    if (md = (by_face =~ /(.). \1. \1./))
+      # get kicker
+      arranged_hand = arrange_hand(md)
+      arranged_hand.match(/(?:\S\S ){3}(\S)\S (\S)/)
+      [
+        [
+          4,
+          Card::face_value(md[1]),
+          Card::face_value($1),
+          Card::face_value($2)
+        ],
+        arranged_hand
+      ]
+    else
+      false
+    end
+  end
+
+  def two_pair?
+    # \1 is the face value of the first pair
+    # \2 is the card in between the first pair and the second pair
+    # \3 is the face value of the second pair
+    if (md = (by_face =~ /(.). \1.(.*?) (.). \3./))
+      # to get the kicker this does the following
+      # md[0] is the regex matched above which includes the first pair and
+      # the second pair but also some cards in the middle so we sub them out
+      # then we add on the cards that came before the first pair, the cards
+      # that were in-between, and the cards that came after.
+      arranged_hand = arrange_hand(md[0].sub(md[2], '') + ' ' +
+          md.pre_match + ' ' + md[2] + ' ' + md.post_match)
+      arranged_hand.match(/(?:\S\S ){4}(\S)/)
+      [
+        [
+          3,
+          Card::face_value(md[1]),    # face value of the first pair
+          Card::face_value(md[3]),    # face value of the second pair
+          Card::face_value($1)        # face value of the kicker
+        ],
+        arranged_hand
+      ]
+    else
+      false
+    end
+  end
+
+  def pair?
+    if (md = (by_face =~ /(.). \1./))
+      # get kicker
+      arranged_hand = arrange_hand(md)
+      arranged_hand.match(/(?:\S\S ){2}(\S)\S\s+(\S)\S\s+(\S)/)
+      [
+        [
+          2,
+          Card::face_value(md[1]),
+          Card::face_value($1),
+          Card::face_value($2),
+          Card::face_value($3)
+        ],
+        arranged_hand
+      ]
+    else
+      false
+    end
+  end
+
+  def highest_card?
+    result = by_face
+    [[1, *result.face_values[0..4]], result.hand.join(' ')]
+  end
+
+  OPS = [
+    ['Royal Flush',     :royal_flush? ],
+    ['Straight Flush',  :straight_flush? ],
+    ['Four of a kind',  :four_of_a_kind? ],
+    ['Full house',      :full_house? ],
+    ['Flush',           :flush? ],
+    ['Straight',        :straight? ],
+    ['Three of a kind', :three_of_a_kind?],
+    ['Two pair',        :two_pair? ],
+    ['Pair',            :pair? ],
+    ['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
+    }.find { |v| v }
+  end
+  
+  alias :rank :hand_rating
+  
+  def score
+    # OPS.map returns an array containing the result of calling each OPS method again
+    # the poker hand. The non-nil cell closest to the front of the array represents
+    # the highest ranking.
+    # find([0]) returns [0] instead of nil if the hand does not match any of the rankings
+    # which is not likely to occur since every hand should at least have a highest card
+    OPS.map { |op|
+      method(op[1]).call()
+    }.find([0]) { |score| score }
+  end
+
+  # Returns a string of the hand arranged based on its rank. Usually this will be the
+  # same as by_face but there are some cases where it makes a difference.
+  #
+  #     ph = PokerHand.new("As 3s 5s 2s 4s")
+  #     ph.sort_using_rank        # => "5s 4s 3s 2s As"
+  #     ph.by_face.just_cards       # => "As 5s 4s 3s 2s"   
+  def sort_using_rank
+    score[1]
+  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[0].compact <=> other_hand.score[0].compact
+  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 new_cards.is_a?(Card) || new_cards.is_a?(String)
+      new_cards = [new_cards]
+    end
+    
+    new_cards.each do |nc|
+      unless @@allow_duplicates
+        raise "A card with the value #{nc} already exists in this hand. Set PokerHand.allow_duplicates to true if you want to be able to add a card more than once." if self =~ /#{nc}/
+      end
+      
+      @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
+  
+  # Same concept as Array#uniq
+  def uniq
+    PokerHand.new(@hand.uniq)
+  end
+  
+  # Resolving methods are just passed directly down to the @hand array
+  RESOLVING_METHODS = [:size, :+, :-]
+  RESOLVING_METHODS.each do |method|
+    class_eval %{
+      def #{method}(*args, &block)
+        @hand.#{method}(*args, &block)
+      end
+    }
+  end
+  
+  private
+  
+  def check_for_duplicates
+    if @hand.size != @hand.uniq.size && !@@allow_duplicates
+      raise "Attempting to create a hand that contains duplicate cards. Set PokerHand.allow_duplicates to true if you do not want to ignore this error."
+    end
+  end
+  
+  # if md is a string, arrange_hand will remove extra white space
+  # if md is a MatchData, arrange_hand returns the matched segment
+  # followed by the pre_match and the post_match
+  def arrange_hand(md)
+      hand = if (md.respond_to?(:to_str))
+        md
+      else
+        md[0] + ' ' + md.pre_match + md.post_match
+      end
+      hand.strip.squeeze(" ")   # remove extra whitespace
+  end
+
+  # delta transform creates a version of the cards where the delta
+  # between card values is in the string, so a regexp can then match a
+  # straight and/or straight flush
+  def delta_transform(use_suit = false)
+    aces = @hand.select { |c| c.face == Card::face_value('A') }
+    aces.map! { |c| Card.new(1,c.suit) }
+
+    base = if (use_suit)
+      (@hand + aces).sort_by { |c| [c.suit, c.face] }.reverse
+    else
+      (@hand + aces).sort_by { |c| [c.face, c.suit] }.reverse
+    end
+
+    result = base.inject(['',nil]) do |(delta_hand, prev_card), card|
+      if (prev_card)
+        delta = prev_card - card.face
+      else
+        delta = 0
+      end
+      # does not really matter for my needs
+      delta = 'x' if (delta > 9 || delta < 0)
+      delta_hand += delta.to_s + card.to_s + ' '
+      [delta_hand, card.face]
+    end
+
+    # we just want the delta transform, not the last cards face too
+    result[0].chop
+  end
+
+  def fix_low_ace_display(arranged_hand)
+    # remove card deltas (this routine is only used for straights)
+    arranged_hand.gsub!(/\S(\S\S)\s*/, "\\1 ")
+
+    # Fix "low aces"
+    arranged_hand.gsub!(/L(\S)/, "A\\1")
+
+    # Remove duplicate aces (this will not work if you have
+    # multiple decks or wild cards)
+    arranged_hand.gsub!(/((A\S).*)\2/, "\\1")
+
+    # cleanup white space
+    arranged_hand.gsub!(/\s+/, ' ')
+    # careful to use gsub as gsub! can return nil here
+    arranged_hand.gsub(/\s+$/, '')
+  end
+  
+end

data/test/test_card.rb

@@ -1,5 +1,4 @@
-require 'test/unit'
-require 'card.rb'
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
 class TestCard < Test::Unit::TestCase
   def setup
@@ -11,16 +10,21 @@ class TestCard < Test::Unit::TestCase
   end
   
   def test_build_from_card
-    c1 = Card.new("2c")
-    c2 = Card.new(c1)
-    assert_equal("2c", c2.to_s)
+    assert_equal("9c", Card.new(@c1).to_s)
   end
   
   def test_class_face_value
-    assert_equal(0, Card.face_value('L'))
+    assert_nil(Card.face_value('L'))
     assert_equal(13, Card.face_value('A'))
   end
 
+  def test_build_from_value
+    assert_equal(@c1, Card.new(7))
+    assert_equal(@c2, Card.new(22))
+    assert_equal(@c3, Card.new(37))
+    assert_equal(@c4, Card.new(52))
+  end
+
   def test_face
     assert_equal(8, @c1.face)
     assert_equal(9, @c2.face)
@@ -42,6 +46,12 @@ class TestCard < Test::Unit::TestCase
     assert_equal(52, @c4.value)
   end
   
+  def test_natural_value
+    assert_equal(1, Card.new("AC").natural_value)
+    assert_equal(15, Card.new("2D").natural_value)
+    assert_equal(52, Card.new("KS").natural_value)
+  end
+
   def test_comparison
     assert(@c1 < @c2)
     assert(@c3 > @c2)

data/test/test_helper.rb

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

data/test/test_poker_hand.rb

@@ -1,6 +1,4 @@
-require 'ruby-poker.rb'
-require 'rubygems'
-require 'shoulda'
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
 class TestPokerHand < Test::Unit::TestCase
   context "A PokerHand instance" do
@@ -114,6 +112,8 @@ class TestPokerHand < Test::Unit::TestCase
     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
   
@@ -145,6 +145,16 @@ class TestPokerHand < Test::Unit::TestCase
       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])
+      # Explanation of [3, 6, 3, 1]
+      # 3: the number for a two pair
+      # 6: highest pair is two 7's
+      # 3: second highest pair is two 4's
+      # 1: kicker is a 2
+    end
   
     context "when duplicates are allowed" do
       setup do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-poker
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - Rob Olson
@@ -9,12 +9,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-24 00:00:00 -08:00
+date: 2009-07-27 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
 description: Ruby library for comparing poker hands and determining the winner.
-email: rko618@gmail.com
+email: rob@thinkingdigitally.com
 executables: []
 
 extensions: []
@@ -27,14 +36,17 @@ files:
 - CHANGELOG
 - examples/deck.rb
 - examples/quick_example.rb
-- lib/card.rb
 - lib/ruby-poker.rb
+- lib/ruby-poker/card.rb
+- lib/ruby-poker/poker_hand.rb
 - LICENSE
 - Rakefile
 - README.rdoc
 - ruby-poker.gemspec
 has_rdoc: true
 homepage: http://github.com/robolson/ruby-poker
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --title
@@ -61,10 +73,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rubypoker
-rubygems_version: 1.3.1
+rubygems_version: 1.3.2
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Poker library in Ruby
 test_files: 
+- test/test_helper.rb
 - test/test_card.rb
 - test/test_poker_hand.rb