hands 0.0.2 → 0.1.0

data/lib/hands/hand_detection.rb

@@ -0,0 +1,153 @@
+module Hands
+  class Hand
+    # @return [Hash] A hash with `:type` and `:cards` keys.
+    def best_hand
+      response = {}
+      HAND_ORDER.reverse.each do |type|
+        cards = self.send(type.to_sym)
+        next unless cards
+        response[:type] = type
+        response[:cards] = cards
+        break
+      end
+      response
+    end
+
+    # @return [Array] Array of {Card} objects with the highest {Card} first
+    def high_card
+      self.cards.sort.reverse
+    end
+
+    # @return [Array, Nil] Array of {Card} objects with the pair first and kickers in decending order or `nil` if there isn't a pair in the {Hand}
+    def pair
+      self.pairs(1)
+    end
+
+    # @return [Array, Nil] Array of {Card} objects with the pairs first and kickers in decending order or `nil` if there isn't two pair in the {Hand}
+    def two_pair
+      self.pairs(2)
+    end
+
+    # @return [Array, Nil] Array of {Card} objects with the three of a kind first and kickers in decending order or `nil` if there isn't three of a kind in the {Hand}
+    def three_of_a_kind
+      self.kinds(3)
+    end
+
+    # @return [Array, Nil] Array of {Card} objects with the straight in decending order or `nil` if there isn't a straight in the {Hand}
+    def straight
+      return nil unless self.cards.length == 5
+      cs = self.cards.sort.reverse
+
+      # Ace's low
+      if cs.first.value == 'a' and cs[1].value == '5'
+        # Move ace to end
+        ace = cs.first
+        cs = cs[1..4]
+        cs << ace
+
+        # Check succession
+        csr = cs.reverse
+        4.times do |i|
+          next if i == 0
+          return nil unless csr[i].value_index == i - 1
+        end
+
+      # Normal
+      else
+        # Check range
+        return nil unless cs.first.value_index - cs.last.value_index == 4
+
+        # Check succession
+        4.times do |i|
+          return nil unless cs[i].value_index == cs[i + 1].value_index + 1
+        end
+      end
+      cs
+    end
+
+    # @return [Array, Nil] Array of {Card} objects with the flush in decending order or `nil` if there isn't a flush in the {Hand}
+    def flush
+      # If all of the {Card}s are the same suit, we have a flush
+      return nil unless self.suits.length == 1
+      self.cards.sort.reverse
+    end
+
+    # @return [Array, Nil] Array of {Card} objects with the full house in decending order or `nil` if there isn't a full house in the {Hand}
+    def full_house
+      dupes = self.duplicates
+      return nil unless dupes.length == 2
+
+      a = []
+      b = []
+
+      hand = self.cards.select do |card|
+        if dupes.first == card.value
+          a << card
+        elsif dupes.last == card.value
+          b << card
+        end
+      end
+
+      return nil unless a.length + b.length == 5
+      self.cards.sort.reverse
+    end
+
+    # @return [Array, Nil] Array of {Card} objects with the four of a kind first the kicker in decending order or `nil` if there isn't four of a kind in the {Hand}
+    def four_of_a_kind
+      self.kinds(4)
+    end
+
+    # @return [Array, Nil] Array of {Card} objects with the straight flush in decending order or `nil` if there isn't a straight flush in the {Hand}
+    def straight_flush
+      return nil unless self.flush
+      self.straight
+    end
+
+    # Hand's index
+    #
+    # Mainly used for internal reasons when comparing {Hand}.
+    #
+    # @return [Integer] index of the {Hand}'s rank
+    # @see HAND_ORDER
+    def hand_index
+      best = self.best_hand
+      return -1 if best.nil?
+      HAND_ORDER.index(best[:type].to_s)
+    end
+
+    protected
+
+    def duplicates
+      pairs = self.cards.collect(&:value)
+      pairs.uniq.select{ |e| (pairs - [e]).size < pairs.size - 1 }
+    end
+
+    def pairs(min)
+      dupes = self.duplicates
+      return nil if dupes.length < min
+
+      hand = self.cards.select do |card|
+        dupes.include?(card.value)
+      end
+
+      hand = hand.sort.reverse
+      hand << (self.cards - hand).sort.reverse
+      hand.flatten
+    end
+
+    def kinds(num)
+      dupes = self.duplicates
+      return nil unless dupes.length == 1
+
+      hand = self.cards.select do |card|
+        dupes.include?(card.value)
+      end
+
+      return nil unless hand.length == num
+
+      hand = hand.sort.reverse
+      hand << (self.cards - hand).sort.reverse
+      hand.flatten
+    end
+  end
+end

data/lib/hands/player.rb

@@ -0,0 +1,19 @@
+module Hands
+  class Player
+    # @return [String] Their name
+    attr_accessor :name
+
+    # @return [Hand] Their hand
+    attr_accessor :hand
+
+    # @return [Table] The {Table} they are sitting at
+    attr_accessor :table
+
+    # Initialize a new {Player}
+    # @param [String] name {Player}'s name
+    def initialize(name = nil)
+      @hand = Hand.new
+      self.name = name if name
+    end
+  end
+end

data/lib/hands/table.rb

@@ -0,0 +1,78 @@
+module Hands
+  # Represents a poker table.
+  class Table
+    # @return [Deck] the {Deck}
+    attr_reader :deck
+
+    # @return [Array] {Card}s on the table
+    attr_reader :community
+
+    # @return [Array] {Card}s in the muck
+    attr_reader :muck
+
+    # @return [Array] {Player}s at the {Table}
+    attr_accessor :players
+
+    # @return [Integer] index of the {Player} that has the dealer button
+    attr_accessor :dealer_position
+
+    # Initializes the table with a {Deck}
+    def initialize
+      @deck = Deck.new
+      @community = []
+      @muck = []
+      @dealer_position = 0
+      @deck.shuffle!
+    end
+
+    # @return [Array] {Player}s ordered by position. Dealer is last.
+    def ordered_players
+      [@players.slice(@dealer_position + 1, @players.length - @dealer_position - 1) + @players.slice(0, @dealer_position + 1)]
+    end
+
+    def deal_player_cards!(number_of_cards = 2)
+      number_of_cards.times do
+        self.ordered_players.flatten.each do |player|
+          player.hand << @deck.pop
+        end
+      end
+    end
+
+    def deal_flop!
+      self.burn_card!
+      self.turn_cards!(3)
+    end
+
+    def deal_turn!
+      self.burn_card!
+      self.turn_card!
+    end
+
+    alias_method :deal_river!, :deal_turn!
+
+    def burn_card!
+      @muck << @deck.pop
+    end
+
+    def turn_cards!(number_of_cards = 1)
+      @community << @deck.pop(number_of_cards)
+      @community.flatten!
+    end
+
+    alias_method :turn_card!, :turn_cards!
+
+    def new_hand!
+      @deck = Deck.new
+      @community = []
+      @muck = []
+      @players.each do |player|
+        player.hand.empty!
+      end
+      @deck.shuffle!
+
+      # Move the button
+      @dealer_position = @dealer_position + 1
+      @dealer_position = 0 if @dealer_position == @players.length
+    end
+  end
+end

data/lib/hands/version.rb

@@ -1,3 +1,4 @@
 module Hands
-  VERSION = '0.0.2'
+  # Gem version
+  VERSION = '0.1.0'
 end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rubygems'
+require 'bundler'
+Bundler.require :test
+require 'minitest/autorun'
+require 'hands'
+
+class Hands::TestCase < MiniTest::Unit::TestCase
+end

data/test/units/card_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+class CardTest < Hands::TestCase
+  def test_that_it_validates_cards
+    card = Hands::Card.new
+    refute card.is_valid?
+    assert card.is_invalid?
+
+    card.suit = :hearts
+    refute card.is_valid?
+
+    card.value = 9
+    assert card.is_valid?
+
+    card.suit = 17
+    refute card.is_valid?
+
+    card.suit = :hearts
+    card.value = 19
+    refute card.is_valid?
+  end
+
+  def test_that_it_allows_integers_for_high_cards
+    card1 = Hands::Card.new(value: 11, suit: :clubs)
+    assert card1.is_valid?
+    assert_equal 'j', card1.value
+
+    card2 = Hands::Card.new(value: 'j', suit: :clubs)
+    assert_equal card1, card2
+  end
+
+  def test_that_its_comparable
+    card1 = Hands::Card.new(value: 2, suit: :hearts)
+    card2 = Hands::Card.new(value: 3, suit: :clubs)
+
+    assert card2 > card1
+    assert card1 < card2
+
+    card1.value = 3
+    assert card1 == card2
+    assert_equal 1, card1.<=>(card2, true)
+    assert_equal -1, card2.<=>(card1, true)
+  end
+
+  def test_that_it_is_sortable
+    c2 = Hands::Card.new(value: 2, suit: :hearts)
+    c3 = Hands::Card.new(value: 3, suit: :hearts)
+    c4 = Hands::Card.new(value: 4, suit: :hearts)
+    c5 = Hands::Card.new(value: 5, suit: :hearts)
+    c6 = Hands::Card.new(value: 6, suit: :hearts)
+    c7 = Hands::Card.new(value: 7, suit: :hearts)
+    c8 = Hands::Card.new(value: 8, suit: :hearts)
+    c9 = Hands::Card.new(value: 9, suit: :hearts)
+    c10 = Hands::Card.new(value: 10, suit: :hearts)
+    cJ = Hands::Card.new(value: 'j', suit: :hearts)
+    cQ = Hands::Card.new(value: 'q', suit: :hearts)
+    cK = Hands::Card.new(value: 'k', suit: :hearts)
+    cA = Hands::Card.new(value: 'a', suit: :hearts)
+
+    cards = [c2, c3, c4, c5, c6, c7, c8, c9, c10, cJ, cQ, cK, cA]
+    assert_equal cards, cards.sort
+  end
+
+  def test_that_it_includes_the_description_in_inspect
+    card = Hands::Card.new(value: 2, suit: :hearts)
+    assert_includes card.inspect, 'Two of Hearts'
+
+    card = Hands::Card.new
+    assert_equal 'invalid', card.description
+    refute_includes card.inspect, 'invalid'
+  end
+end

data/test/units/deck_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class DeckTest < Hands::TestCase
+  def test_shuffle
+    deck = Hands::Deck.new
+    cards = deck.cards.collect(&:description)
+    deck.shuffle!
+    refute_equal cards, deck.cards.collect(&:description)
+  end
+
+  def test_popping
+    deck = Hands::Deck.new
+    card = deck.pop
+    refute_includes deck.cards, card
+  end
+end

data/test/units/hand_detection_test.rb

@@ -0,0 +1,165 @@
+require 'test_helper'
+
+class HandDetectionTest < Hands::TestCase
+
+  def test_best_hand
+    hand = Hands::Hand.new
+    hand << Hands::Card[7, :hearts]
+    hand << Hands::Card[7, :spades]
+    hand << Hands::Card[4, :diamonds]
+    hand << Hands::Card[9, :hearts]
+    hand << Hands::Card[9, :clubs]
+    assert_equal 'two_pair', hand.best_hand[:type]
+  end
+
+
+  #### High Card
+
+  def test_high_card
+    hand = Hands::Hand.new
+    hand << Hands::Card[2, :hearts]
+    hand << Hands::Card[9, :clubs]
+    hand << Hands::Card[7, :hearts]
+    hand << Hands::Card['a', :spades]
+    hand << Hands::Card[4, :diamonds]
+    assert_equal %w{a 9 7 4 2}, hand.high_card.collect(&:value)
+    refute hand.pair
+    refute hand.two_pair
+  end
+
+
+  #### Pair
+
+  def test_pair
+    hand = Hands::Hand.new
+    hand << Hands::Card[9, :hearts]
+    hand << Hands::Card[9, :clubs]
+    hand << Hands::Card[7, :hearts]
+    hand << Hands::Card[2, :spades]
+    hand << Hands::Card[4, :diamonds]
+    assert_equal %w{9 9 7 4 2}, hand.pair.collect(&:value)
+    refute hand.two_pair
+  end
+
+
+  #### Two Pair
+
+  def test_two_pair
+    hand = Hands::Hand.new
+    hand << Hands::Card[7, :hearts]
+    hand << Hands::Card[7, :spades]
+    hand << Hands::Card[4, :diamonds]
+    hand << Hands::Card[9, :hearts]
+    hand << Hands::Card[9, :clubs]
+    assert_equal %w{9 9 7 7 4}, hand.two_pair.collect(&:value)
+    assert_equal hand.pair, hand.two_pair
+  end
+
+
+  #### Three of a Kind
+
+  def test_three_of_a_kind
+    hand = Hands::Hand.new
+    hand << Hands::Card[7, :hearts]
+    hand << Hands::Card[7, :spades]
+    hand << Hands::Card[7, :diamonds]
+    hand << Hands::Card[3, :hearts]
+    hand << Hands::Card[9, :clubs]
+    assert_equal 'three_of_a_kind', hand.best_hand[:type]
+  end
+
+
+  #### Straight
+
+  def test_straight
+    hand = Hands::Hand.new
+    hand << Hands::Card[2, :hearts]
+    hand << Hands::Card[3, :spades]
+    hand << Hands::Card[4, :diamonds]
+    hand << Hands::Card[5, :hearts]
+    hand << Hands::Card[6, :clubs]
+    assert_equal 'straight', hand.best_hand[:type]
+  end
+
+  def test_straight_when_ace_is_low
+    hand = Hands::Hand.new
+    hand << Hands::Card['A', :hearts]
+    hand << Hands::Card[2, :spades]
+    hand << Hands::Card[3, :diamonds]
+    hand << Hands::Card[4, :hearts]
+    hand << Hands::Card[5, :clubs]
+    assert_equal 'straight', hand.best_hand[:type]
+  end
+
+  def test_straight_when_ace_is_high
+    hand = Hands::Hand.new
+    hand << Hands::Card[10, :hearts]
+    hand << Hands::Card['J', :spades]
+    hand << Hands::Card['Q', :diamonds]
+    hand << Hands::Card['K', :hearts]
+    hand << Hands::Card['A', :clubs]
+    assert_equal 'straight', hand.best_hand[:type]
+  end
+
+  def test_straights_dont_wrap_around
+    hand = Hands::Hand.new
+    hand << Hands::Card['J', :spades]
+    hand << Hands::Card['Q', :diamonds]
+    hand << Hands::Card['K', :hearts]
+    hand << Hands::Card['A', :clubs]
+    hand << Hands::Card[2, :hearts]
+    assert_equal 'high_card', hand.best_hand[:type]
+  end
+
+
+  #### Flush
+
+  def test_flush
+    hand = Hands::Hand.new
+    hand << Hands::Card[6, :hearts]
+    hand << Hands::Card[7, :hearts]
+    hand << Hands::Card[8, :hearts]
+    hand << Hands::Card[2, :hearts]
+    hand << Hands::Card[4, :hearts]
+    assert_equal 'flush', hand.best_hand[:type]
+  end
+
+
+  #### Full House
+
+  def test_full_house
+    hand = Hands::Hand.new
+    hand << Hands::Card[7, :hearts]
+    hand << Hands::Card[7, :spades]
+    hand << Hands::Card[7, :diamonds]
+    hand << Hands::Card[9, :spades]
+    hand << Hands::Card[9, :clubs]
+    assert_equal 'full_house', hand.best_hand[:type]
+  end
+
+
+  #### Four of a Kind
+
+  def test_four_of_a_kind
+    hand = Hands::Hand.new
+    hand << Hands::Card[7, :hearts]
+    hand << Hands::Card[7, :spades]
+    hand << Hands::Card[7, :diamonds]
+    hand << Hands::Card[7, :clubs]
+    hand << Hands::Card[9, :clubs]
+    assert_equal 'four_of_a_kind', hand.best_hand[:type]
+  end
+
+
+  #### Straight Flush
+
+  def test_straight_flush
+    hand = Hands::Hand.new
+    hand << Hands::Card[2, :hearts]
+    hand << Hands::Card[3, :hearts]
+    hand << Hands::Card[4, :hearts]
+    hand << Hands::Card[5, :hearts]
+    hand << Hands::Card[6, :hearts]
+    assert_equal 'straight_flush', hand.best_hand[:type]
+  end
+end