ruby-poker 0.1.2 → 0.2.0

data/CHANGELOG

@@ -7,4 +7,10 @@
 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
+    * More test cases coming soon
+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

data/README

@@ -2,7 +2,7 @@
 
 == Author
 
-Robert Olson mailto:rko618@gmail.com
+Robert Olson mailto:rko618 [at] gmail.com
 
 == License
 
@@ -21,20 +21,28 @@ The homepage of this project is located at
 
 == Description
 
-This class handles poker logic for 5 card poker hands.
+Ruby-Poker handles the logic for poker hands.
 
 Card representations can be passed to the PokerHand constructor as a string or an array.
-Face cards (cards ten, jack, queen, king, and ace) can be created using their
-value (10, 11, 12, 13, 14) or letter representation (T, J, Q, K, A)
+Face cards (cards ten, jack, queen, king, and ace) are created using their 
+letter representation (T, J, Q, K, A).
 
 == Examples
 
 In this section some examples show what can be done with this class.
 
     hand1 = PokerHand.new("8H 9C TC JD QH")
-    hand2 = PokerHand.new(["3D", "3C", "3S", "13D", "14H"])
-    puts hand1                => 8H 9C 10C 11D 12H
+    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 13D 14H
-    puts hand2.rank           => Three of a Kind
+    puts hand2                => 3d 3c 3s Kd Ah (Three of a kind)
+    puts hand2.rank           => Three of a kind
     puts hand1 > hand2        => true
+
+== 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.

data/examples/deck.rb

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

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

data/lib/card.rb

@@ -1,22 +1,92 @@
-class PokerHand
-  
-  class Card
-    include Comparable
-    attr_reader :suit, :value
-
-    def initialize card_str
-      card_str = card_str.gsub("T","10").gsub("J","11").gsub("Q","12").gsub("K","13").gsub("A","14")
-      @value = card_str[0, card_str.length-1].to_i
-      @suit = card_str[-1,1]
-    end
+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 <=> card2
-      @value <=> card2.value
+  def Card.face_value(face)
+    if (face)
+      FACE_VALUES[face.upcase] - 1
+    else
+      nil
     end
+  end
 
-    def to_s
-      @value.to_s + @suit
-    end
-  end # class Card
+  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
   
-end # class PokerHand
+  public
+
+  # got a little carried away with this constructor ;-)
+  def initialize(*value)
+    if (value.size == 1)
+      if (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
+
+  def to_s
+    FACES[@face].chr + SUITS[@suit].chr
+  end
+
+  def <=> card2
+    @face <=> card2.face
+  end
+end

data/lib/ruby-poker.rb

@@ -1 +1,280 @@
-require 'poker_hand'
+require 'card.rb'
+
+class PokerHand
+  include Comparable
+  attr_reader :hand
+  
+  def initialize(cards = [])
+    if cards.is_a? Array
+      @hand = cards.map { |str| Card.new(str.to_s) }
+    elsif cards.respond_to?(:to_str)
+      @hand = cards.scan(/\S{2,3}/).map { |str| Card.new(str) }
+    else
+      @hand = cards
+    end
+  end
+
+  def face_values
+    @hand.map { |c| c.face }
+  end
+
+  def by_suit
+    PokerHand.new(@hand.sort_by { |c| [c.suit, c.face] }.reverse)
+  end
+
+  def by_face
+    PokerHand.new(@hand.sort_by { |c| [c.face, c.suit] }.reverse)
+  end
+
+  def =~ (re)
+    re.match(@hand.join(' '))
+  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
+      until transform.match(/^\S{3}( [1-9x]\S\S)+( 0\S\S)*$/) do
+        transform.gsub!(/(\s0\S\S)(.*)/, "\\2\\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?
+    if (md = (by_face =~ /(.). \1.(.*) (.). \3./))
+      # get kicker
+      arranged_hand = arrange_hand(md[0] + ' ' +
+          md.pre_match + ' ' + md[2] + ' ' + md.post_match)
+      arranged_hand.match(/(?:\S\S ){4}(\S)/)
+      [
+        [
+          3,
+          Card::face_value(md[1]),
+          Card::face_value(md[3]),
+          Card::face_value($1)
+        ],
+        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? ],
+  ]
+
+  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
+
+  def arranged_hand
+    score[1] + " (#{hand_rating})"
+  end
+
+  def just_cards
+    @hand.join(" ")
+  end
+  
+  def to_s
+    just_cards + " (" + hand_rating + ")"
+  end
+  
+  def <=> other_hand
+    self.score <=> other_hand.score
+  end
+  
+  protected
+  
+  def arrange_hand(md)
+      hand = if (md.respond_to?(:to_str))
+        md
+      else
+        md[0] + ' ' + md.pre_match + md.post_match
+      end
+      hand.gsub!(/\s+/, ' ')
+      hand.gsub(/\s+$/,'')
+  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/test/test_card.rb

@@ -0,0 +1,44 @@
+# Code Generated by ZenTest v. 3.8.0
+#                 classname: asrt / meth =  ratio%
+#                      Card:    0 /    4 =   0.00%
+
+require 'test/unit' unless defined? $ZENTEST and $ZENTEST
+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_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
+end
+
+# Number of errors detected: 9

data/test/test_poker_hand.rb

@@ -0,0 +1,112 @@
+# Code Generated by ZenTest v. 3.8.0
+#                 classname: asrt / meth =  ratio%
+#                 PokerHand:    0 /   24 =   0.00%
+
+require 'test/unit' unless defined? $ZENTEST and $ZENTEST
+require 'ruby-poker.rb'
+
+class TestPokerHand < Test::Unit::TestCase
+  def setup
+    @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
+  
+  def test_arranged_hand
+    assert_equal("As Ah Ac 9c 2d (Three of a kind)", @trips.arranged_hand)
+  end
+
+  def test_by_face
+    assert_equal([13, 13, 13, 8, 1], @trips.by_face.hand.collect {|c| c.face})
+  end
+
+  def test_by_suit
+    assert_equal([3, 2, 1, 0, 0], @trips.by_suit.hand.collect {|c| c.suit})
+  end
+
+  def test_face_values
+    assert_equal([1, 8, 13, 13, 13], @trips.face_values)
+  end
+
+  def test_flush_eh
+    assert @flush.flush?
+    assert !@trips.flush?
+  end
+
+  def test_four_of_a_kind_eh
+    assert !@trips.four_of_a_kind?
+    assert PokerHand.new("AD 9C AS AH AC")
+  end
+
+  def test_full_house_eh
+    assert !@trips.full_house?
+    assert @full_boat.full_house?
+  end
+
+  def test_hand
+    assert_equal 5, @trips.hand.size
+    assert_instance_of Card, @trips.hand[0]
+  end
+
+  def test_hand_rating
+    assert_equal "Three of a kind", @trips.hand_rating
+    assert_equal "Full house", @full_boat.hand_rating
+  end
+
+  def test_rank
+    # rank is an alias for hand_rating
+    assert_not_nil @trips.rank
+  end
+
+  def test_highest_card_eh
+    # hard to test, make sure it does not return null
+    assert PokerHand.new("2D 4S 6C 8C TH").highest_card?
+  end
+
+  def test_just_cards
+    assert_equal("2d 9c As Ah Ac", @trips.just_cards)
+  end
+
+  def test_pair_eh
+    assert !PokerHand.new("5C JC 2H 7S 3D").pair?
+    assert PokerHand.new("6D 7C 5D 5H 3S").pair?
+  end
+  
+  def test_royal_flush_eh
+    assert !@flush.royal_flush?
+    assert PokerHand.new("AD KD QD JD TD").royal_flush?
+  end
+
+  def test_score
+    assert_equal([4, 13, 8, 1], @trips.score[0])
+  end
+
+  def test_straight_eh
+    assert @straight.straight?
+    assert PokerHand.new("AH 2S 3D 4H 5D").straight?
+  end
+
+  def test_straight_flush_eh
+    assert !@flush.straight_flush?
+    assert !@straight.straight_flush?
+    assert PokerHand.new("8H 9H TH JH QH AS").straight_flush?
+  end
+
+  def test_three_of_a_kind_eh
+    assert @trips.three_of_a_kind?
+  end
+
+  def test_two_pair_eh
+    assert PokerHand.new("2S 2D TH TD 4S").two_pair?
+    assert !PokerHand.new("6D 7C 5D 5H 3S").two_pair?
+  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"))
+  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.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - Robert Olson
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-12 00:00:00 -08:00
+date: 2008-01-21 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -24,13 +24,12 @@ extra_rdoc_files:
 - CHANGELOG
 - LICENSE
 files: 
+- examples/deck.rb
 - examples/quick_example.rb
 - lib/card.rb
-- lib/poker_hand.rb
-- lib/poker_helper.rb
-- lib/rank.rb
 - lib/ruby-poker.rb
-- test/tc_poker_hand.rb
+- test/test_card.rb
+- test/test_poker_hand.rb
 - README
 - CHANGELOG
 - LICENSE
@@ -61,4 +60,5 @@ signing_key:
 specification_version: 2
 summary: Ruby library for determining the winner in a game of poker.
 test_files: 
-- test/tc_poker_hand.rb
+- test/test_card.rb
+- test/test_poker_hand.rb

data/lib/poker_hand.rb

@@ -1,159 +0,0 @@
-require 'poker_helper.rb'
-require 'rank.rb'
-require 'card.rb'
-
-class PokerHand
-    
-  include PokerHelper
-  include Comparable
-  attr_reader :cards, :values_hash
-  
-  def initialize cards
-    @cards = Array.new
-    @values_hash = Hash.new(0)
-
-    begin
-      if cards.class == String
-        cards = cards.split
-      end
-
-      cards.each {|c| @cards << Card.new(c)}
-      
-      @cards.each {|c| @values_hash[c.value] += 1}
-    rescue
-      raise "Unable to process cards input. Please check the documentation for acceptable input formats"
-    end
-  end
-  
-  def rank
-    @rank ||= self.determine_rank
-  end
-  
-  # Returns an array of all the values in the hand. Does not
-  # sort the values before returning them so Array#sort should
-  # be called on the return value if sorting is desired.
-  def values
-    @cards.collect {|c| c.value}
-  end
-  
-  # Flush if the cards are all the same suit.
-  def flush?
-    @cards.collect {|c| c.suit}.uniq.size == 1
-  end
-  
-  # Straight if all cards are consecutive values.
-  def straight?
-    straight = true   # innocent until proven guilty
-    c_values = self.values.sort
-    i = c_values.first
-    c_values.each do |v|
-      straight &&= (v == i)
-      i += 1
-    end
-    return straight
-  end
-
-  # Royal Flush: Ten, Jack, Queen, King, Ace, in same suit.  
-  def royal_flush?
-    self.flush? and self.values.sort == [10,11,12,13,14]
-  end
-    
-  # Straight Flush: All cards are consecutive values of same suit.
-  def straight_flush?    
-    self.flush? and self.straight?
-  end
-  
-  # Full House: Three of a kind and a pair.
-  def full_house?
-    @values_hash.has_value?(3) and @values_hash.has_value?(2)
-  end
-  
-  # Three of a Kind: Three cards of the same value.
-  def three_of_a_kind?
-    @values_hash.has_value?(3) and not full_house?
-  end    
-  
-  # Four of a Kind: Four cards of the same value.  
-  def four_of_a_kind?
-    @values_hash.has_value?(4)
-  end
-  
-  # Two Pair: Two different pairs.
-  def two_pair?
-    @values_hash.select {|k, v| v == 2}.size == 2   # check if two seperate values have two occurances
-  end
-  
-  # One Pair: Two cards of the same value.
-  def one_pair?
-    @values_hash.select {|k, v| v == 2}.size == 1
-  end
-
-  def <=> hand2
-    if self.rank != hand2.rank
-      self.rank <=> hand2.rank
-    else  # we have a tie... do a tie breaker
-      case self.rank.value    # both hands have the same rank
-      when 0, 4, 5, 8  # highest card, straight, flush, straight flush
-        # check who has the highest card, if same move to the next card, etc
-        self.values.sort.reverse <=> hand2.values.sort.reverse
-      when 1  # two people with one pair
-        # check which pair is higher, if the pairs are the same then remove the pairs and check
-        # for highest card
-        hand1_pair = @values_hash.index(2)  # get key(card value) of the duplicate pair
-        hand2_pair = hand2.values_hash.index(2)
-        if hand1_pair == hand2_pair
-          return singles(self.values).reverse <=> singles(hand2.values).reverse
-        else
-          return hand1_pair <=> hand2_pair
-        end
-      when 2  # two people with two pairs
-        # check who has the higher pair, if the pairs are the same
-        # then remove the pairs and check for highest card
-        hand1_pairs = duplicates(self.values).reverse
-        hand2_pairs = duplicates(hand2.values).reverse
-        if hand1_pairs == hand2_pairs
-          return singles(self.values) <=> singles(hand2.values)   # there will be only one card remaining
-        else
-          return hand1_pairs <=> hand2_pairs
-        end
-      when 3, 6  # three_of_a_kind, full house
-        @values_hash.index(3) <=> hand2.values_hash.index(3)
-      when 7  # four of a kind
-        @values_hash.index(4) <=> hand2.values_hash.index(4)
-      when 9  # royal flush
-        return 0  # royal flushes always tie
-      end
-    end
-  end
-  
-  def to_s
-    @cards.inject("") {|str, c| str << "#{c.to_s} "}.rstrip
-  end
-  
-  protected
-  
-  def determine_rank
-    if royal_flush?
-      r = Rank::ROYAL_FLUSH
-    elsif straight_flush?
-      r = Rank::STRAIGHT_FLUSH
-    elsif four_of_a_kind?
-      r = Rank::FOUR_OF_A_KIND
-    elsif full_house?
-      r = Rank::FULL_HOUSE
-    elsif flush?
-      r = Rank::FLUSH
-    elsif straight?
-      r = Rank::STRAIGHT
-    elsif three_of_a_kind?
-      r = Rank::THREE_OF_A_KIND
-    elsif two_pair?
-      r = Rank::TWO_PAIR
-    elsif one_pair?
-      r = Rank::PAIR
-    else
-      r = Rank::HIGH_CARD
-    end
-    return Rank.new(r)
-  end
-end # class PokerHand

data/lib/poker_helper.rb

@@ -1,23 +0,0 @@
-module PokerHelper
-  # Returns array of elements that only occur once
-  # [1, 1, 2, 3] => [2, 3]
-  def singles array1
-    counts = Hash.new(0)
-    array1.each do |value|
-      counts[value] += 1
-    end
-
-    return counts.collect {|key,value| value == 1 ? key : nil }.compact.sort
-  end
-  
-  # Returns an array containing values that we duplicated in the original array
-  # [1, 2, 3, 1] => [1]
-  def duplicates array1
-    counts = Hash.new(0)
-    array1.each do |value|
-      counts[value] += 1
-    end
-
-    return counts.collect {|key,value| value > 1 ? key : nil }.compact.sort
-  end
-end # module ArrayHelper

data/lib/rank.rb

@@ -1,48 +0,0 @@
-class PokerHand
-
-  # Rank objects maintain the poker value of the hand. Ex. Full House
-  class Rank
-    include Comparable
-    attr_accessor :value  
-    
-    HIGH_CARD = 0
-    PAIR = 1
-    TWO_PAIR = 2
-    THREE_OF_A_KIND = 3
-    STRAIGHT = 4
-    FLUSH = 5
-    FULL_HOUSE = 6
-    FOUR_OF_A_KIND = 7
-    STRAIGHT_FLUSH = 8
-    ROYAL_FLUSH = 9
-  
-    # Creates a new Rank instance of <code>value</code>
-    # Values can be 0-9. Consider using the Rank constants
-    # for the hand values.
-    def initialize value
-      @value = value
-    end
-  
-    # Returns the text representation of the poker rank. Ex. "Two Pair"
-    def to_s
-      case @value
-        when 0: "High Card"
-        when 1: "Pair"
-        when 2: "Two Pair"
-        when 3: "Three of a Kind"
-        when 4: "Straight"
-        when 5: "Flush"
-        when 6: "Full House"
-        when 7: "Four of a Kind"
-        when 8: "Straight Flush"
-        when 9: "Royal Flush"
-        else "Unknown"
-      end
-    end
-  
-    def <=> other
-      @value <=> other.value
-    end
-  end   # class Rank
-
-end

data/test/tc_poker_hand.rb

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-require 'test/unit'
-require 'rubygems'
-require 'ruby-poker'
-
-class TestPokerHand < Test::Unit::TestCase
-  def setup
-    @hand1 = PokerHand.new("6D 7C 5D 5H 3S")
-    @hand2 = PokerHand.new(["5C", "JC", "2H", "5S", "3D"])
-  end
-  
-  def test_comparable
-    assert_equal(-1, @hand1 <=> @hand2)
-  end
-end