robolson-ruby-poker 0.3.0

data/CHANGELOG

@@ -0,0 +1,49 @@
+2008-12-30 (0.3.1)
+    * Fixed bug (#20407) Raise an exception when creating a new hand with duplicates
+    * Added PokerHand#uniq method
+    * Removed deprecated `Gem::manage_gems` from Rakefile
+2008-05-17 (0.3.0)
+    * Changed Card#== to compare based on card suit and face value. Before it only compared the face value of two cards. Warning: This change may potentially break your program if you were comparing Card objects directly.
+    * Replaced `PokerHand#arranged_hand` with `PokerHand#sort_using_rank` which is more descriptive. This loosely corresponds to bug #20194.
+    * Bug [#20196] 'rank' goes into an infinite loop.
+    * Bug [#20195] Allows the same card to be entered into the hand.
+    * Bug [#20344] sort_using_rank does not return expected results
+    
+2008-04-20 (0.2.4)
+    * Modernized the Rakefile
+    * Updated to be compatible with Ruby 1.9    
+    
+2008-04-06 (0.2.2)
+    * Fixed bug where two hands that had the same values but different suits returned not equal    
+    
+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()
+    
+2008-01-21 (0.2.0)
+    * Merged Patrick Hurley's poker solver
+    * 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      
+    
+2008-01-12 (0.1.2)
+    * Fixed critical bug that was stopping the whole program to not work
+    * Added some test cases as a result
+    * More test cases coming soon      
+    
+2008-01-12 (0.1.1)
+    * Ranks are now a class.
+    * Extracted card, rank, and arrays methods to individual files
+    * Added gem packaging
+        
+2008-01-10 (0.1.0)
+    * Initial version
+
+
+
+
+
+
+
+    

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2008, Robert Olson
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the distribution.
+    * Neither the name of the author nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,51 @@
+= Poker library in Ruby
+
+== Author
+
+Rob Olson (rko618 [at] gmail)
+
+== Description
+
+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 letter representation (T, J, Q, K, A).
+
+== Install
+
+    sudo gem install ruby-poker
+
+== Examples
+
+In this section some examples show what can be done with this class.
+
+    require 'rubygems'
+    require 'ruby-poker'
+    
+    hand1 = PokerHand.new("8H 9C TC JD QH")
+    hand2 = PokerHand.new(["3D", "3C", "3S", "KD", "AH"])
+    puts hand1                => 8h 9c Tc Jd Qh (Straight)
+    puts hand1.just_cards     => 8h 9c Tc Jd Qh
+    puts hand1.rank           => Straight
+    puts hand2                => 3d 3c 3s Kd Ah (Three of a kind)
+    puts hand2.rank           => Three of a kind
+    puts hand1 > hand2        => true
+
+== Duplicates
+
+By default ruby-poker will not raise an exception if you add the same card to a hand twice. You can tell ruby-poker to not allow duplicates by doing the following
+
+    PokerHand.allow_duplicates = false
+    
+Place that line near the beginning of your program. The change is program wide so once allow_duplicates is set to false, _all_ poker hands will raise an exception if a duplicate card is added to the hand.
+
+== Compatibility
+
+Ruby-Poker is compatible with Ruby 1.8 and Ruby 1.9.
+
+== History
+
+In the 0.2.0 release Patrick Hurley's Texas Holdem code from http://rubyquiz.com/quiz24.html was merged into ruby-poker.
+
+== License
+
+This is free software; you can redistribute it and/or modify it under the terms of the BSD license. See LICENSE for more details.

data/Rakefile

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+require 'rake/rdoctask'
+require "rake/testtask"
+require 'rake/gempackagetask'
+
+begin
+  require "rubygems"
+rescue LoadError
+  nil
+end
+
+RUBYPOKER_VERSION = "0.3.0"
+
+Gem::Specification.new do |s|
+  s.name     = "ruby-poker"
+  s.version  = RUBYPOKER_VERSION
+  s.date     = "2008-05-17"
+  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.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"]
+  s.require_paths << 'lib'
+  
+  s.extra_rdoc_files = ["README", "CHANGELOG", "LICENSE"]
+  s.rdoc_options << '--title' << 'Ruby Poker Documentation' <<
+                    '--main'  << 'README.rdoc' <<
+                    '--inline-source' << '-q'
+  
+  # s.add_dependency("thoughtbot-shoulda", ["> 2.0.0"])
+end
+
+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" ]
+  test.verbose = true
+  test.warning = true
+end
+
+desc "Start autotest"
+task :autotest do
+  ruby "-I lib -w /usr/bin/autotest"
+end
+
+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

data/examples/deck.rb

@@ -0,0 +1,29 @@
+# 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|
+      # careful not to double include the aces...
+      Card::FACES[1..-1].each_byte do |face|
+        @cards.push(Card.new(face.chr, suit.chr))
+      end
+    end
+    shuffle()
+  end
+
+  def deal
+    @cards.pop
+  end
+
+  def empty?
+    @cards.empty?
+  end
+end

data/examples/quick_example.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'ruby-poker'
+
+hand1 = PokerHand.new("8H 9C TC JD QH")
+hand2 = PokerHand.new(["3D", "3C", "3S", "KD", "AH"])
+puts hand1
+puts hand1.just_cards
+puts hand1.rank
+puts hand2
+puts hand2.rank
+puts hand1 > hand2

data/lib/card.rb

@@ -0,0 +1,125 @@
+class Card
+  SUITS = "cdhs"
+  FACES = "L23456789TJQKA"
+  SUIT_LOOKUP = {
+    'c' => 0,
+    'd' => 1,
+    'h' => 2,
+    's' => 3,
+    'C' => 0,
+    'D' => 1,
+    'H' => 2,
+    'S' => 3,
+  }
+  FACE_VALUES = {
+    'L' =>  1,   # this is a magic low ace
+    '2' =>  2,
+    '3' =>  3,
+    '4' =>  4,
+    '5' =>  5,
+    '6' =>  6,
+    '7' =>  7,
+    '8' =>  8,
+    '9' =>  9,
+    'T' => 10,
+    'J' => 11,
+    'Q' => 12,
+    'K' => 13,
+    'A' => 14,
+  }
+
+  def Card.face_value(face)
+    if (face)
+      FACE_VALUES[face.upcase] - 1
+    else
+      nil
+    end
+  end
+
+  protected
+  
+  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()
+    @face  = (value % FACES.size())
+  end
+
+  def build_from_face_suit(face, suit)
+    @face  = Card::face_value(face)
+    @suit  = SUIT_LOOKUP[suit]
+    @value = (@suit * FACES.size()) + (@face - 1)
+  end
+
+  def build_from_face_suit_values(face, suit)
+    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
+
+  def initialize(*value)
+    if (value.size == 1)
+      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])
+      end
+    elsif (value.size == 2)
+      if (value[0].respond_to?(:to_str) &&
+          value[1].respond_to?(:to_str))
+        build_from_face_suit(value[0], value[1])
+      elsif (value[0].respond_to?(:to_int) &&
+             value[1].respond_to?(:to_int))
+        build_from_face_suit_values(value[0], value[1])
+      end
+    end
+  end
+
+  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
+  
+  # Returns true if the cards are the same card. Meaning they
+  # have the same suit and the same face value.
+  def == card2
+    @value == card2.value
+  end
+  alias :eql? :==
+  
+  # Compute a hash-code for this Card. Two Cards with the same
+  # content will have the same hash code (and will compare using eql?). 
+  def hash
+    @value.hash
+  end
+end

data/lib/ruby-poker.rb

@@ -0,0 +1,401 @@
+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] <=> other_hand.score[0]
+  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

data/ruby-poker.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+  s.name     = "ruby-poker"
+  s.version  = "0.3.0"
+  s.date     = "2008-05-17"
+  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.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"]
+  s.require_paths << 'lib'
+  
+  s.extra_rdoc_files = ["README", "CHANGELOG", "LICENSE"]
+  s.rdoc_options << '--title' << 'Ruby Poker Documentation' <<
+                    '--main'  << 'README.rdoc' <<
+                    '--inline-source' << '-q'
+  
+  # s.add_dependency("thoughtbot-shoulda", ["> 2.0.0"])
+end

data/test/test_card.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require 'card.rb'
+
+class TestCard < Test::Unit::TestCase
+  def setup
+    # testing various input formats for cards
+    @c1 = Card.new("9c")
+    @c2 = Card.new("TD")
+    @c3 = Card.new("jh")
+    @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'))
+  end
+
+  def test_face
+    assert_equal(8, @c1.face)
+    assert_equal(9, @c2.face)
+    assert_equal(10, @c3.face)
+    assert_equal(11, @c4.face)          
+  end
+
+  def test_suit
+    assert_equal(0, @c1.suit)
+    assert_equal(1, @c2.suit)
+    assert_equal(2, @c3.suit)
+    assert_equal(3, @c4.suit)
+  end
+
+  def test_value
+    assert_equal(7, @c1.value)
+    assert_equal(22, @c2.value)
+    assert_equal(37, @c3.value)
+    assert_equal(52, @c4.value)
+  end
+  
+  def test_comparison
+    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

data/test/test_poker_hand.rb

@@ -0,0 +1,210 @@
+require 'ruby-poker.rb'
+require 'rubygems'
+require 'shoulda'
+
+class TestPokerHand < Test::Unit::TestCase
+  context "A PokerHand instance" do
+  
+    setup do
+      @trips = PokerHand.new("2D 9C AS AH AC")
+      @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")
+    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
+
+    should "return card sorted by face value" do
+      assert_equal([13, 13, 13, 8, 1], @trips.by_face.hand.collect {|c| c.face})
+    end
+
+    should "return cards sorted by suit" do
+      assert_equal([3, 2, 1, 0, 0], @trips.by_suit.hand.collect {|c| c.suit})
+    end
+
+    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?
+    end
+
+    should "recognize a flush" do
+      assert @flush.flush?
+      assert !@trips.flush?
+    end
+
+    should "recognize a four of a kind" do
+      assert !@trips.four_of_a_kind?
+      assert PokerHand.new("AD 9C AS AH AC")
+    end
+
+    should "recognize a full house" do
+      assert !@trips.full_house?
+      assert @full_boat.full_house?
+    end
+    
+    should "recognize a straight" do
+      assert @straight.straight?
+      assert PokerHand.new("AH 2S 3D 4H 5D").straight?
+    end
+
+    should "recognize a three of a kind" do
+      assert @trips.three_of_a_kind?
+    end
+
+    should "recognize a two pair" do
+      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?
+    end
+
+    should "have an instance variable hand that is an array of Cards" do
+      assert_instance_of Card, @trips.hand[0]
+    end
+
+    should "return the hand's rating as a string" do
+      assert_equal "Three of a kind", @trips.hand_rating
+      assert_equal "Full house", @full_boat.hand_rating
+    end
+
+    should "respond to rank" do
+      # rank is an alias for hand_rating
+      assert_respond_to @trips, :rank
+    end
+
+    should "return the hand as a string" do
+      assert_equal("2d 9c As Ah Ac", @trips.just_cards)
+    end
+
+    should "return the hand's score" do
+      assert_equal([4, 13, 8, 1], @trips.score[0])
+    end
+
+    should "be able to match regular expressions" do
+      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(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
+      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
+  
+    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")    
+        assert_raise RuntimeError do
+          ph << "2d"
+        end
+    
+        PokerHand.allow_duplicates = true
+      end
+    end
+    
+  end
+end
+

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: robolson-ruby-poker
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Rob Olson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-17 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Ruby library for comparing poker hands and determining the winner.
+email: rko618@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- LICENSE
+files: 
+- CHANGELOG
+- examples/deck.rb
+- examples/quick_example.rb
+- lib/card.rb
+- lib/ruby-poker.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+- ruby-poker.gemspec
+- README
+has_rdoc: true
+homepage: http://github.com/robolson/ruby-poker
+post_install_message: 
+rdoc_options: 
+- --title
+- Ruby Poker Documentation
+- --main
+- README.rdoc
+- --inline-source
+- -q
+require_paths: 
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rubypoker
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Poker library in Ruby
+test_files: 
+- test/test_card.rb
+- test/test_poker_hand.rb