bakineggs-poker 1.3

data/lib/card.rb

@@ -0,0 +1,68 @@
+module Poker
+  class Card
+    include Comparable
+
+    SUITS_SHORTHAND = {
+      'Spades' => 's',
+      'Diamonds' => 'd',
+      'Clubs' => 'c',
+      'Hearts' => 'h'
+    }
+    SUITS = SUITS_SHORTHAND.keys
+    VALUES = {
+      'Ace' => 14,
+      'King' => 13,
+      'Queen' => 12,
+      'Jack' => 11,
+      '10' => 10,
+      '9' => 9,
+      '8' => 8,
+      '7' => 7,
+      '6' => 6,
+      '5' => 5,
+      '4' => 4,
+      '3' => 3,
+      '2' => 2,
+    }
+    FACES = VALUES.keys
+    FACES_SHORTHAND = {
+      'Ace' => 'A',
+      'King' => 'K',
+      'Queen' => 'Q',
+      'Jack' => 'J',
+      '10' => 'T',
+      '9' => '9',
+      '8' => '8',
+      '7' => '7',
+      '6' => '6',
+      '5' => '5',
+      '4' => '4',
+      '3' => '3',
+      '2' => '2'
+    }
+
+    attr_reader :value, :suit
+
+    def initialize suit_or_chars, face_or_value = nil
+      if face_or_value.nil?
+        raise ArgumentError unless suit_or_chars.length == 2
+        face_or_value = FACES_SHORTHAND.index(suit_or_chars[0, 1])
+        suit_or_chars = SUITS_SHORTHAND.index(suit_or_chars[1, 1])
+      end
+      self.suit = suit_or_chars
+      self.value = VALUES[face_or_value] || face_or_value
+      raise ArgumentError unless SUITS.include?(suit_or_chars) && VALUES.has_value?(value)
+    end
+
+    def face
+      VALUES.index(value)
+    end
+
+    def <=> other_card
+      value <=> other_card.value
+    end
+
+    private
+      attr_writer :value, :suit
+  end
+end

data/lib/deck.rb

@@ -0,0 +1,28 @@
+module Poker
+  class Deck
+    attr_reader :cards
+
+    def initialize
+      @cards = Card::SUITS.map do |suit|
+        Card::FACES.map do |value|
+          Card.new(suit, value)
+        end
+      end.flatten
+      @card_index = 0
+    end
+
+    def shuffle
+      @cards = @cards.sort_by {rand}
+      @card_index = 0
+      self
+    end
+
+    def next(quantity = 1)
+      raise IndexError if @card_index + quantity > 52
+      @cards[@card_index...(@card_index += quantity)]
+    end
+
+    private
+      attr_writer :cards
+  end
+end

data/lib/hand.rb

@@ -0,0 +1,164 @@
+module Poker
+  class Hand
+    include Comparable
+    attr_reader :cards
+
+    def initialize *params
+      @cards = params.map do |param|
+        if param.is_a? Hand
+          param.cards
+        elsif param.is_a? Card
+          param
+        elsif param.is_a? String
+          param.split(' ').map {|str| Card.new str}
+        end
+      end.flatten.uniq.sort.reverse
+    end
+
+    def straight_flush?
+      @straight_flush ||= suited_cards.any? do |cards|
+        Hand.new(*cards).straight?
+      end
+    end
+
+    def quads?
+      @quads ||= matched_cards.any? do |cards|
+        cards.length >= 4
+      end
+    end
+
+    def full_house?
+      @full_house ||= set? && two_pair?
+    end
+
+    def flush?
+      @flush ||= suited_cards.any? do |cards|
+        cards.length >= 5
+      end
+    end
+
+    def straight?
+      @straight ||= !straight_cards.empty?
+    end
+
+    def set?
+      @set ||= matched_cards.any? do |cards|
+        cards.length >= 3
+      end
+    end
+
+    def two_pair?
+      @two_pair ||= matched_cards.length >= 2
+    end
+
+    def pair?
+      @pair ||= matched_cards.length >= 1
+    end
+
+    def four_to_flush?
+      @four_to_flush ||= suited_cards.any? do |cards|
+        cards.length >= 4
+      end
+    end
+
+    def open_ended?
+      @open_ended ||= straight_cards(4).any? do |cards|
+        cards.first.face != 'Ace' && cards.last.face != 'Ace'
+      end
+    end
+
+    def gutshot?
+      @gutshot ||= !gutshot_cards.empty?
+    end
+
+    def double_gutshot?
+      @double_gutshot ||= gutshot_cards.length >= 2
+    end
+
+    def <=> other_hand
+      return rank <=> other_hand.rank unless rank == other_hand.rank
+      return 0 if tie_breaker == other_hand.tie_breaker
+      tie_breaker.each_with_index do |card, i|
+        compared = card.value <=> other_hand.tie_breaker[i].value
+        return compared unless compared == 0
+      end
+    end
+
+    protected
+      def rank
+        @rank ||= if straight_flush?: 8
+        elsif quads?: 7
+        elsif full_house?: 6
+        elsif flush?: 5
+        elsif straight?: 4
+        elsif set?: 3
+        elsif two_pair?: 2
+        elsif pair?: 1
+        else; 0
+        end
+      end
+
+      def tie_breaker
+        @tie_breaker ||= if flush?
+          Hand.new(*suited_cards.find{|cards| cards.length >= 5}).unsuited!.tie_breaker
+        elsif quads?
+          quads = matched_cards.find{|cards| cards.length == 4}
+          quads + [(@cards - quads).first]
+        elsif full_house?
+          set = matched_cards.find{|cards| cards.length == 3}
+          set + (matched_cards - [set]).first.first(2)
+        elsif straight?
+          [straight_cards.last.last]
+        elsif set?
+          set = matched_cards.first
+          set + (@cards - set).first(2)
+        elsif two_pair?
+          two_pair = matched_cards.first(2).flatten
+          two_pair + [(@cards - two_pair).first]
+        elsif pair?
+          pair = matched_cards.first
+          pair + (@cards - pair).first(3)
+        else
+          @cards.first(5)
+        end
+      end
+
+      def unsuited!
+        @suited_cards = []
+        self
+      end
+
+    private
+      def matched_cards
+        @matched_cards ||= @cards.map{|card| card.value}.uniq.map do |value|
+          cards = @cards.select{|card| card.value == value}
+          cards.length > 1 ? cards : nil
+        end.compact
+      end
+
+      def suited_cards
+        @suited_cards ||= @cards.map{|card| card.suit}.uniq.map do |suit|
+          @cards.select{|card| card.suit == suit}
+        end
+      end
+
+      def straight_cards(length = 5)
+        @straight_cards ||= {}
+        @straight_cards[length] ||= (1..14-(length-1)).map do |low| # straight can start at a low ace up to a 10
+          high = low + (length - 1)
+          cards = (low..high).map do |value|
+            @cards.find{|card| card.value % 13 == value % 13} # %13 allows an ace to be high or low
+          end.compact
+        end.select{|cards| cards.length == length}
+      end
+
+      def gutshot_cards
+        @gutshot_cards ||= (1..10).map do |low|
+          high = low + 4
+          (low..high).reject do |value|
+            @cards.find{|card| card.value % 13 == value % 13}
+          end
+        end.reject{|cards| cards.length != 1}.uniq.flatten
+      end
+  end
+end

data/lib/poker.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + '/card'
+require File.dirname(__FILE__) + '/hand'
+require File.dirname(__FILE__) + '/deck'

data/spec/card_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/helper'
+
+module Poker
+  describe Card, '#new' do
+    it 'should accept the four suits' do
+      lambda {
+        ['Spades', 'Diamonds', 'Clubs', 'Hearts'].each do |suit|
+          Card.new(suit, 'Ace')
+        end
+      }.should_not raise_error
+    end
+
+    it 'should reject unknown suits' do
+      lambda { Card.new('Rubies', 'Ace') }.should raise_error(ArgumentError)
+    end
+
+    it 'should accept a string of a card name' do
+      lambda {
+        Card.new('Spades', 'Ace')
+        Card.new('Spades', 'King')
+        Card.new('Spades', 'Queen')
+        Card.new('Spades', 'Jack')
+        (2..10).each do |value|
+          Card.new('Spades', value.to_s)
+        end
+      }.should_not raise_error
+    end
+
+    it 'should accept short representations of a card' do
+      faces = {'Ace' => 'A', 'King' => 'K', 'Queen' => 'Q', 'Jack' => 'J', '10' => 'T'}
+      (2..9).each {|value| faces[value.to_s] = value.to_s }
+      {'Spades' => 's', 'Diamonds' => 'd', 'Clubs' => 'c', 'Hearts' => 'h'}.each do |suit, suit_short|
+        faces.each do |face, face_short|
+          Card.new("#{face_short}#{suit_short}").should == Card.new(suit, face)
+        end
+      end
+    end
+
+    it 'should reject unknown short representations' do
+      lambda { Card.new 'Ar' }.should raise_error(ArgumentError)
+      lambda { Card.new '1s' }.should raise_error(ArgumentError)
+      lambda { Card.new '11s' }.should raise_error(ArgumentError)
+      lambda { Card.new 'AsJc' }.should raise_error(ArgumentError)
+    end
+
+    it 'should reject unknown card names' do
+      lambda { Card.new('Spades', '1') }.should raise_error(ArgumentError)
+      lambda { Card.new('Spades', '11') }.should raise_error(ArgumentError)
+      lambda { Card.new('Spades', 'Joker') }.should raise_error(ArgumentError)
+    end
+
+    it 'should accept card values' do
+      lambda {
+        (2..14).each do |value|
+          Card.new('Spades', value)
+        end
+      }.should_not raise_error
+    end
+
+    it 'should consider cards made by face and value the same' do
+      Card.new('Spades', 'Ace').should == Card.new('Spades', 14)
+      Card.new('Spades', 'King').should == Card.new('Spades', 13)
+      Card.new('Spades', 'Queen').should == Card.new('Spades', 12)
+      Card.new('Spades', 'Jack').should == Card.new('Spades', 11)
+      (2..10).each do |value|
+        Card.new('Spades', value.to_s).should == Card.new('Spades', value)
+      end
+    end
+
+    it 'should reject values outside the range' do
+      lambda { Card.new('Spades', 1) }.should raise_error(ArgumentError)
+      lambda { Card.new('Spades', 15) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe Card, '#face' do
+    it 'should return the face for that card' do
+      Card.new('Spades', 'Ace').face.should == 'Ace'
+      Card.new('Spades', 'King').face.should == 'King'
+      Card.new('Spades', 'Queen').face.should == 'Queen'
+      Card.new('Spades', 'Jack').face.should == 'Jack'
+      (2..10).each do |value|
+        Card.new('Spades', value).face.should == value.to_s
+      end
+    end
+  end
+
+  describe Card, '#value' do
+    it 'should return the value for that card' do
+      Card.new('Spades', 'Ace').value.should == 14
+      Card.new('Spades', 'King').value.should == 13
+      Card.new('Spades', 'Queen').value.should == 12
+      Card.new('Spades', 'Jack').value.should == 11
+      (2..10).each do |value|
+        Card.new('Spades', value).value.should == value
+      end
+    end
+  end
+
+  describe Card, '#<=>' do
+    it 'should order the cards by value' do
+      Card.new('Spades', 'Ace').should > Card.new('Spades', 'King')
+      Card.new('Spades', 'King').should > Card.new('Spades', 'Queen')
+      Card.new('Spades', 'Queen').should > Card.new('Spades', 'Jack')
+      Card.new('Spades', 'Jack').should > Card.new('Spades', '10')
+      (2..9).each do |value|
+        Card.new('Spades', value+1).should > Card.new('Spades', value)
+      end
+    end
+  end
+end

data/spec/deck_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/helper'
+
+module Poker
+  describe Deck, '#next' do
+    it 'should give you the number of cards you ask for' do
+      count = rand 10
+      Deck.new.next(count).length.should == count
+    end
+
+    it 'should give 1 card by default' do
+      Deck.new.next.length.should == 1
+    end
+
+    it 'should not give out the same card twice' do
+      Deck.new.next(52).uniq.length.should == 52
+    end
+
+    it 'should not give out the same card(s) on subsequent calls' do
+      deck = Deck.new
+      count = rand(10)+1
+      deck.next(count).should_not == deck.next(count)
+    end
+
+    it 'should eventually run out of cards' do
+      lambda {
+        Deck.new.next(53)
+      }.should raise_error(IndexError)
+      lambda {
+        deck = Deck.new
+        deck.next 40
+        deck.next 13
+      }.should raise_error(IndexError)
+    end
+  end
+
+  describe Deck, '#shuffle' do
+    it 'should allow you to take out more cards' do
+      deck = Deck.new
+      deck.next 52
+      lambda {
+        deck.shuffle.next 52
+      }.should_not raise_error
+    end
+
+    it 'should change the order of the cards' do
+      deck = Deck.new
+      deck.next(52).should_not == deck.shuffle.next(52)
+    end
+  end
+end

data/spec/hand_spec.rb

@@ -0,0 +1,656 @@
+require File.dirname(__FILE__) + '/helper'
+
+module Poker
+  describe Hand, '#new' do
+    before do
+      @cards = [
+        Card.new('Hearts', '6'),
+        Card.new('Spades', 'Queen'),
+        Card.new('Diamonds', '4'),
+        Card.new('Clubs', '7'),
+        Card.new('Diamonds', 'Jack'),
+        Card.new('Spades', '8')
+      ]
+    end
+
+    it 'should contain the given cards' do
+      Hand.new(*@cards).cards.sort.should == @cards.sort
+    end
+
+    it 'should contain the cards in any given hands' do
+      Hand.new(Hand.new(*@cards[0..2]), Hand.new(*@cards[3..5])).cards.sort.should == @cards.sort
+    end
+
+    it 'should accept a combination of hands and cards' do
+      Hand.new(Hand.new(*@cards[0..2]), *@cards[3..5]).cards.sort.should == @cards.sort
+    end
+
+    it 'should ignore the same card if given twice' do
+      Hand.new(@cards[3], *@cards).cards.sort.should == @cards.sort
+    end
+
+    it 'should ignore the same card if given in two hands' do
+      Hand.new(Hand.new(*@cards[0..3]), Hand.new(*@cards[2..5])).cards.sort.should == @cards.sort
+    end
+
+    it 'should ignore the same card if given in a combo of cards and hands' do
+      Hand.new(Hand.new(*@cards[0..3]), *@cards[2..5]).cards.sort.should == @cards.sort
+    end
+
+    it 'should accept a string of card values' do
+      Hand.new('6h Qs 4d 7c Jc 8s').should == Hand.new(*@cards)
+    end
+
+    it 'should accept string of card calues intermixed with cards and hands' do
+      Hand.new('7c Jc', Hand.new(@cards[5]), *@cards[0..2]).should == Hand.new(*@cards)
+    end
+  end
+
+  describe Hand do
+    before do
+      @straight_flush = Hand.new '6s 5s 9s 7s 8s'
+      @quads = Hand.new '6h 6s 6c 7s 6d'
+      @full_house = Hand.new '6s 6h 6d 7s 7c'
+      @flush = Hand.new '6s Qs 3s 7s 8s'
+      @straight = Hand.new '6s 5c 9s 7d 8h'
+      @set = Hand.new '6s 6h 9s 6c 8d'
+      @two_pair = Hand.new '6s 5h 6c 5d 8s'
+      @pair = Hand.new '6h 5s 8c 7d 8s'
+      @high_card = Hand.new '6h Qs 4d 7c Jd'
+    end
+
+    describe 'straight flush' do
+      it 'should be a straight flush' do
+        @straight_flush.should be_straight_flush
+      end
+
+      it 'should be a flush' do
+        @straight_flush.should be_flush
+      end
+
+      it 'should be a straight' do
+        @straight_flush.should be_straight
+      end
+
+      it 'should not be anything else' do
+        @straight_flush.should_not be_pair
+        @straight_flush.should_not be_two_pair
+        @straight_flush.should_not be_set
+        @straight_flush.should_not be_full_house
+        @straight_flush.should_not be_quads
+      end
+
+      describe 'wheel' do
+        it 'should be a straight flush' do
+          Hand.new(
+            Card.new('Spades', 'Ace'),
+            Card.new('Spades', '2'),
+            Card.new('Spades', '3'),
+            Card.new('Spades', '4'),
+            Card.new('Spades', '5')
+          ).should be_straight_flush
+        end
+      end
+    end
+
+    describe 'quads' do
+      it 'should be quads' do
+        @quads.should be_quads
+      end
+
+      it 'should be a set' do
+        @quads.should be_set
+      end
+
+      it 'should be a pair' do
+        @quads.should be_set
+      end
+
+      it 'should not be anything else' do
+        @quads.should_not be_two_pair
+        @quads.should_not be_straight
+        @quads.should_not be_flush
+        @quads.should_not be_full_house
+        @quads.should_not be_straight_flush
+      end
+    end
+
+    describe 'full house' do
+      it 'should be a full house' do
+        @full_house.should be_full_house
+      end
+
+      it 'should be a set' do
+        @full_house.should be_set
+      end
+
+      it 'should be two pair' do
+        @full_house.should be_two_pair
+      end
+
+      it 'should be a pair' do
+        @full_house.should be_pair
+      end
+
+      it 'should not be anything else' do
+        @full_house.should_not be_straight
+        @full_house.should_not be_flush
+        @full_house.should_not be_quads
+        @full_house.should_not be_straight_flush
+      end
+    end
+
+    describe 'flush' do
+      it 'should be a flush' do
+        @flush.should be_flush
+      end
+
+      it 'should not be anything else' do
+        @flush.should_not be_pair
+        @flush.should_not be_two_pair
+        @flush.should_not be_set
+        @flush.should_not be_straight
+        @flush.should_not be_full_house
+        @flush.should_not be_quads
+        @flush.should_not be_straight_flush
+      end
+    end
+
+    describe 'straight' do
+      it 'should be a straight' do
+        @straight.should be_straight
+      end
+
+      it 'should not be anything else' do
+        @straight.should_not be_pair
+        @straight.should_not be_two_pair
+        @straight.should_not be_set
+        @straight.should_not be_flush
+        @straight.should_not be_full_house
+        @straight.should_not be_quads
+        @straight.should_not be_straight_flush
+      end
+
+      describe 'wheel' do
+        it 'should be a straight' do
+          Hand.new(
+            Card.new('Spades', 'Ace'),
+            Card.new('Clubs', '2'),
+            Card.new('Spades', '3'),
+            Card.new('Hearts', '4'),
+            Card.new('Diamonds', '5')
+          ).should be_straight
+        end
+      end
+    end
+
+    describe 'set' do
+      it 'should be a set' do
+        @set.should be_set
+      end
+
+      it 'should be a pair' do
+        @set.should be_pair
+      end
+
+      it 'should not be anything else' do
+        @set.should_not be_two_pair
+        @set.should_not be_straight
+        @set.should_not be_flush
+        @set.should_not be_full_house
+        @set.should_not be_quads
+        @set.should_not be_straight_flush
+      end
+    end
+
+    describe 'two pair' do
+      it 'should be two pair' do
+        @two_pair.should be_two_pair
+      end
+
+      it 'should be a pair' do
+        @two_pair.should be_pair
+      end
+
+      it 'should not be anything else' do
+        @two_pair.should_not be_set
+        @two_pair.should_not be_straight
+        @two_pair.should_not be_flush
+        @two_pair.should_not be_full_house
+        @two_pair.should_not be_quads
+        @two_pair.should_not be_straight_flush
+      end
+    end
+
+    describe 'pair' do
+      it 'should be a pair' do
+        @pair.should be_pair
+      end
+
+      it 'should not be anything else' do
+        @pair.should_not be_two_pair
+        @pair.should_not be_set
+        @pair.should_not be_straight
+        @pair.should_not be_flush
+        @pair.should_not be_full_house
+        @pair.should_not be_quads
+        @pair.should_not be_full_house
+      end
+    end
+
+    describe 'high card' do
+      it 'should not be anything else' do
+        @high_card.should_not be_pair
+        @high_card.should_not be_two_pair
+        @high_card.should_not be_set
+        @high_card.should_not be_straight
+        @high_card.should_not be_flush
+        @high_card.should_not be_full_house
+        @high_card.should_not be_quads
+        @high_card.should_not be_straight_flush
+      end
+    end
+
+    describe 'straight and flush' do
+      before do
+        @straight_and_flush = Hand.new 'As Ts 9s 8c 7s 6s'
+      end
+
+      it 'should be a straight' do
+        @straight_and_flush.should be_straight
+      end
+
+      it 'should be a flush' do
+        @straight_and_flush.should be_flush
+      end
+
+      it 'should not be a straight flush' do
+        @straight_and_flush.should_not be_straight_flush
+      end
+    end
+
+    describe 'four to flush' do
+      before do
+        @four_to_flush = Hand.new 'As Ts 8c 7s 6s'
+      end
+
+      it 'should be four to a flush' do
+        @four_to_flush.should be_four_to_flush
+      end
+
+      it 'should not be a flush' do
+        @four_to_flush.should_not be_flush
+      end
+    end
+
+    describe 'open ended' do
+      before do
+        @open_ended = Hand.new 'As 9s 8c 7s 6s'
+      end
+
+      it 'should be open ended' do
+        @open_ended.should be_open_ended
+      end
+
+      it 'should not be a straight' do
+        @open_ended.should_not be_straight
+      end
+
+      it 'should not include Ace through 4' do
+        Hand.new('As 2c 3s 4h 8d').should_not be_open_ended
+      end
+
+      it 'should not include Jack through Ace' do
+        Hand.new('As Kc Qs Jh 8d').should_not be_open_ended
+      end
+    end
+
+    describe 'gutshot' do
+      it 'should include 1-card gaps between 1 card and 3 others' do
+        Hand.new('Js 2c 5s 4h 6d').should be_gutshot
+      end
+
+      it 'should include 1-card gaps between 2 cards and 2 others' do
+        Hand.new('Js 2c 5s 3h 6d').should be_gutshot
+      end
+
+      it 'should include 1-card gaps between 3 cards and 1 other' do
+        Hand.new('Js 2c 3s 4h 6d').should be_gutshot
+      end
+
+      it 'should include Ace through 4' do
+        Hand.new('As 2c 3s 4h 8d').should be_gutshot
+      end
+
+      it 'should include Jack through Ace' do
+        Hand.new('As Kc Qs Jh 8d').should be_gutshot
+      end
+    end
+
+    describe 'double gutshot' do
+      it 'should include 2 1-card gaps between 1, 3, and 1 cards' do
+        Hand.new('4s 6c 7s 8h Td').should be_double_gutshot
+      end
+
+      it 'should include 2 1-card gaps between 2, 2, and 2 cards' do
+        Hand.new('4s 5c 7s 8h Td Jh').should be_double_gutshot
+      end
+
+      it 'should include 2 1-card gaps between 3, 1, and 3 cards' do
+        Hand.new('4s 5c 6s 8h Td Jh Qc').should be_double_gutshot
+      end
+
+      it 'should not include 2-card gaps between 2 cards and 3 cards' do
+        Hand.new('4s 5c 8s 9h Td').should_not be_double_gutshot
+      end
+
+      it 'should not include 2-card gaps between 3 cards and 2 cards' do
+        Hand.new('4s 5c 6s 9h Td').should_not be_double_gutshot
+      end
+
+      it 'should not include 1-card gaps between 3 cards and 3 cards' do
+        Hand.new('4s 5c 6s 8c 9h Td').should_not be_double_gutshot
+      end
+    end
+
+    describe 'rankings' do
+      before do
+        @highest_quads = Hand.new 'Ac Ah As Ad Kh'
+        @highest_full_house = Hand.new 'Ac Ah As Kd Kh'
+        @highest_flush = Hand.new 'Ac Kc Qc Jc 9c'
+        @highest_straight = Hand.new 'Ac Kh Qs Jd Th'
+        @highest_set = Hand.new 'Ac Ah As Kd Qh'
+        @highest_two_pair = Hand.new 'Ac Ah Ks Kd Qh'
+        @highest_pair = Hand.new 'Ah Ad Ks Qd Jc'
+        @highest_high_card = Hand.new 'Ah Ks Qd Jc 9d'
+      end
+
+      describe 'straight flush' do
+        before do
+          @highest_straight_flush = Hand.new 'Ac Kc Qc Jc Tc'
+          @lowest_straight_flush = Hand.new 'Ac 2c 3c 4c 5c'
+        end
+
+        it 'should beat a smaller straight flush' do
+          @highest_straight_flush.should > @straight_flush
+          @straight_flush.should > @lowest_straight_flush
+        end
+
+        it 'should beat any quads' do
+          @lowest_straight_flush.should > @highest_quads
+        end
+
+        it 'should beat any full house' do
+          @lowest_straight_flush.should > @highest_full_house
+        end
+
+        it 'should beat any flush' do
+          @lowest_straight_flush.should > @highest_flush
+        end
+
+        it 'should beat any straight' do
+          @lowest_straight_flush.should > @highest_straight
+        end
+
+        it 'should beat any set' do
+          @lowest_straight_flush.should > @highest_set
+        end
+
+        it 'should beat any two pair' do
+          @lowest_straight_flush.should > @highest_two_pair
+        end
+
+        it 'should beat any pair' do
+          @lowest_straight_flush.should > @highest_pair
+        end
+
+        it 'should beat any high card' do
+          @lowest_straight_flush.should > @highest_high_card
+        end
+      end
+
+      describe 'quads' do
+        before do
+          @lowest_quads = Hand.new '2c 2h 2s 2d 3h'
+        end
+
+        it 'should beat smaller quads' do
+          @highest_quads.should > @quads
+          @quads.should > @lowest_quads
+        end
+
+        it 'should beat any full house' do
+          @lowest_quads.should > @highest_full_house
+        end
+
+        it 'should beat any flush' do
+          @lowest_quads.should > @highest_flush
+        end
+
+        it 'should beat any straight' do
+          @lowest_quads.should > @highest_straight
+        end
+
+        it 'should beat any set' do
+          @lowest_quads.should > @highest_set
+        end
+
+        it 'should beat any two pair' do
+          @lowest_quads.should > @highest_two_pair
+        end
+
+        it 'should beat any pair' do
+          @lowest_quads.should > @highest_pair
+        end
+
+        it 'should beat any high card' do
+          @lowest_quads.should > @highest_high_card
+        end
+
+        it 'should consider the quads first' do
+          Hand.new('Ac Ah As Ad 2h').should > Hand.new('Kc Kh Ks Kd Qh')
+        end
+
+        it 'should consider the kicker if the quads are the same' do
+          Hand.new('Ac Ah As Ad Qh').should > Hand.new('Ac Ah As Ad Jh')
+        end
+      end
+
+      describe 'full house' do
+        before do
+          @lowest_full_house = Hand.new '2c 2h 2s 3d 3h'
+        end
+
+        it 'should beat a smaller full house' do
+          @highest_full_house.should > @full_house
+          @full_house.should > @lowest_full_house
+        end
+
+        it 'should beat any flush' do
+          @lowest_full_house.should > @highest_flush
+        end
+
+        it 'should beat any straight' do
+          @lowest_full_house.should > @highest_straight
+        end
+
+        it 'should beat any set' do
+          @lowest_full_house.should > @highest_set
+        end
+
+        it 'should beat any two pair' do
+          @lowest_full_house.should > @highest_two_pair
+        end
+
+        it 'should beat any pair' do
+          @lowest_full_house.should > @highest_pair
+        end
+
+        it 'should beat any high card' do
+          @lowest_full_house.should > @highest_high_card
+        end
+
+        it 'should consider the set first' do
+          Hand.new('Ac Ah As 2d 2h').should > Hand.new('Kc Kh Ks Qd Qh')
+        end
+
+        it 'should consider the pair if the set is the same' do
+          Hand.new('Ac Ah As Qd Qh').should > Hand.new('Ac Ah As Jd Jh')
+        end
+      end
+
+      describe 'flush' do
+        before do
+          @lowest_flush = Hand.new '2c 3c 4c 5c 7c'
+        end
+
+        it 'should beat a smaller flush' do
+          @highest_flush.should > @flush
+          @flush.should > @lowest_flush
+        end
+
+        it 'should beat any straight' do
+          @lowest_flush.should > @highest_straight
+        end
+
+        it 'should beat any set' do
+          @lowest_flush.should > @highest_set
+        end
+
+        it 'should beat any two pair' do
+          @lowest_flush.should > @highest_two_pair
+        end
+
+        it 'should beat any pair' do
+          @lowest_flush.should > @highest_pair
+        end
+
+        it 'should beat any high card' do
+          @lowest_flush.should > @highest_high_card
+        end
+
+        it 'should compare the highest cards in the flush' do
+          Hand.new('As Ks 4s 3s 2s').should > Hand.new('As Qs Js Ts 9s')
+        end
+      end
+
+      describe 'straight' do
+        before do
+          @lowest_straight = Hand.new 'Ac 2h 3s 4d 5h'
+        end
+
+        it 'should beat a smaller straight' do
+          @highest_straight.should > @straight
+          @straight.should > @lowest_straight
+        end
+
+        it 'should beat any set' do
+          @lowest_straight.should > @highest_set
+        end
+
+        it 'should beat any two pair' do
+          @lowest_straight.should > @highest_two_pair
+        end
+
+        it 'should beat any pair' do
+          @lowest_straight.should > @highest_pair
+        end
+
+        it 'should beat any high card' do
+          @lowest_straight.should > @highest_high_card
+        end
+      end
+
+      describe 'set' do
+        before do
+          @lowest_set = Hand.new '2s 2c 2h 3d 4c'
+        end
+
+        it 'should beat a smaller set' do
+          @highest_set.should > @set
+          @set.should > @lowest_set
+        end
+
+        it 'should beat any two pair' do
+          @lowest_set.should > @highest_two_pair
+        end
+
+        it 'should beat any pair' do
+          @lowest_set.should > @highest_pair
+        end
+
+        it 'should beat any high card' do
+          @lowest_set.should > @highest_high_card
+        end
+
+        it 'should beat smaller sets' do
+          Hand.new('7s 7c 7d 2h 3c').should > Hand.new('6s 6c 6d Kh Ac')
+        end
+
+        it 'should beat smaller kickers' do
+          Hand.new('7s 7c 7d Ah Jc').should > Hand.new('7s 7c 7d Ah Tc')
+        end
+      end
+
+      describe 'two pair' do
+        before do
+          @lowest_two_pair = Hand.new '2s 2c 3h 3d 4c'
+        end
+
+        it 'should beat a smaller two pair' do
+          @highest_two_pair.should > @two_pair
+          @two_pair.should > @lowest_two_pair
+        end
+
+        it 'should beat any pair' do
+          @lowest_two_pair.should > @highest_pair
+        end
+
+        it 'should beat any high card' do
+          @lowest_two_pair.should > @highest_high_card
+        end
+
+        it 'should beat smaller first pairs' do
+          Hand.new('As Ac 2d 2h 3c').should > Hand.new('Ks Kc Qd Qh Ac')
+        end
+
+        it 'should beat smaller second pairs' do
+          Hand.new('Ks Kc Qd Qh 2c').should > Hand.new('Ks Kc Jd Jh Ac')
+        end
+
+        it 'should beat smaller kickers' do
+          Hand.new('Ks Kc Qd Qh Ac').should > Hand.new('Ks Kc Qd Qh Jc')
+        end
+      end
+
+      describe 'pair' do
+        before do
+          @lowest_pair = Hand.new '2s 2c 3h 4d 5d'
+        end
+
+        it 'should beat a smaller pair' do
+          @highest_pair.should > @pair
+          @pair.should > @lowest_pair
+        end
+
+        it 'should beat any high card' do
+          @lowest_pair.should > @highest_high_card
+        end
+
+        it 'should beat smaller kickers' do
+          Hand.new('As Ac Kd Qh 2c').should > Hand.new('As Ac Kd Jh Tc')
+        end
+      end
+
+      describe 'high card' do
+        it 'should beat a smaller high card' do
+          @highest_high_card.should > @high_card
+        end
+
+        it 'should beat a smaller subsequent card' do
+          Hand.new('As Kc 4d 3h 2c').should > Hand.new('As Qc Jd Th 9c')
+        end
+      end
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'spec'
+require File.dirname(__FILE__) + '/../lib/poker'

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: bakineggs-poker
+version: !ruby/object:Gem::Version 
+  version: "1.3"
+platform: ruby
+authors: 
+- Dan Barry
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A library for constructing and comparing poker hands. Also provides a deck of cards.
+email: dan@bakineggs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/card.rb
+- lib/deck.rb
+- lib/hand.rb
+- lib/poker.rb
+has_rdoc: false
+homepage: http://github.com/danbarry/poker
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- 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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A library for constructing and comparing poker hands. Also provides a deck of cards.
+test_files: 
+- spec/helper.rb
+- spec/card_spec.rb
+- spec/deck_spec.rb
+- spec/hand_spec.rb