rora 0.0.5

data/lib/rora/model/table.rb

@@ -0,0 +1,40 @@
+#
+#
+#
+class Table
+  attr_reader :board, :deck, :pot, :seats
+
+  def initialize seats=nil
+    @seats = Array.new(seats.nil? ? 9 : seats)
+    @board = Board.new
+    @pot = Pot.new
+    @deck = Deck.new
+  end
+
+  def reset
+    @board = Board.new
+    @pot = Pot.new
+    @deck = Deck.new
+  end
+
+  def add player, seat_number=nil
+    if !location.nil?
+      raise ArgumentException, "Seat #{seat_number} is already taken by another player." if @seats[seat_number - 1] != nil
+      @seats[seat_number - 1] = player
+    else
+      @seats.each_index do |x|
+        if @seats[x].nil?
+          @seats[x] = player
+          return
+        end
+      end
+    end
+    self
+  end
+
+  def remove player
+    @seats.delete player
+    self
+  end
+
+end

data/lib/rora/repository/hand_repository.rb

@@ -0,0 +1,133 @@
+require 'csv'
+require 'singleton'
+
+class HandRepository
+  include Singleton
+
+  def initialize
+    @hands = Array.new
+    @table = Hash.new
+    CSV.foreach("lib/rora/hands.csv") do |row|
+      @table[row[1].to_i] = [row[0].to_i, row[3], row[4], row[5].to_f]
+    end
+  end
+
+  def find id
+    @table.fetch id
+  end
+
+  # Returns all possible poker hands.
+  #
+  # No Arguments
+  # If no arguments are provided, this method will return all
+  # 2,598,960 (52c5) poker hands.
+  #
+  # Starting Hand
+  # If a starting hand is provided as an argument, this method returns all
+  # poker hands that can be made with the given starting hand. A standard
+  # deck of 52 cards is assumed. Exactly 19,600 (50c3) 5-card poker hands
+  # will be returned for any given starting hand.
+  #
+  # Starting Hand and Deck
+  # If a deck is provided along with a starting hand, this method will return
+  # all poker hands that can be made with the given starting hand and cards
+  # that remain in the deck.
+  #
+  # Starting Hand and Board
+  # If a board is provided along with a starting hand, this method will return
+  # all poker hands that can be made with the given starting hand and board. In
+  # this scenario, a standard deck of 52 cards is assumed. A deck will contain
+  # exactly 50 cards after the starting hand has been dealt. The deck will contain
+  # 47 cards after the flop, 46 cards after the turn and 45 cards after the river.
+  #
+  # Once the community cards have been dealt, there are 21 (7c5) ways to
+  # choose a 5-card poker hand from the 5 community cards and 2 hole cards.
+  # The total number of hands that will be returned from this method are as
+  # follows:
+  #
+  # If the board has 5 community cards, flop turn & river have been
+  # dealt:
+  # 21 hands -> 21 (7c5) # 1 (45c0)
+  #
+  # If the board has 4 community cards, flop and turn have been dealt:
+  # 966 hands -> 21 (7c5) # 46 (46c1)
+  #
+  # If the board has 3 community cards, flop has been dealt:
+  # 22701 hands -> 21 (7c5) # 1081 (47c2)
+  #
+  # Starting Hand, Board and Deck
+  # This method will return all poker hands that can be made with the given starting
+  # hand and cards that remain in the deck.
+  def list arguments=nil
+    return hands if arguments.nil? || arguments[:starting_hand].nil?
+
+    starting_hand = arguments[:starting_hand]
+    deck = arguments[:deck].nil? ? Deck.new : arguments[:deck]
+    board = arguments[:board]
+    hands = Array.new
+
+    if !board.nil?
+      raise RuntimeError if board.contains_any? starting_hand.cards
+      if board.cards.size == 5
+        (board.cards + starting_hand.cards).combination(5).to_a.each { |cards| hands << Hand.new(cards) }
+        return hands
+      else
+        deck.remove(starting_hand).remove(board).combination(5 - board.cards.size).to_a.each do |cards|
+          (starting_hand.cards + board.cards + cards).combination(5).to_a.each { |cds| hands << Hand.new(cds) }
+        end
+        return hands
+      end
+    end
+
+    deck.remove(starting_hand).combination(3).each { |cards| hands << Hand.new(cards + starting_hand.cards) }
+    hands
+  end
+
+  # Returns unique poker hands.
+  #
+  # While there are over 2.5 million distinct poker hands, many of these hands have the same
+  # value in poker. To elaborate on this a bit, consider the number of hands a player could have
+  # containing a pair of fours with a 10-7-6 kicker:
+  #
+  # 4♣ 4♦ 6♠ 7♥ 10♥
+  # 4♠ 4♦ 6♠ 7♥ 10♥
+  # 4♥ 4♦ 6♠ 7♥ 10♥
+  # 4♣ 4♠ 6♠ 7♥ 10♥
+  # 4♣ 4♦ 6♠ 7♥ 10♦
+  # 4♣ 4♦ 6♠ 7♦ 10♥
+  # 4♣ 4♦ 6♣ 7♥ 10♥
+  # 4♣ 4♦ 6♠ 7♠ 10♥
+  # 4♣ 4♦ 6♠ 7♦ 10♠
+  # 4♣ 4♦ 6♣ 7♥ 10♣
+  #
+  # This list goes on much further - in fact, there are exactly 768 distinct hand combinations that
+  # contain of exactly one pair of fours with a 10-7-6 kicker. Each of these 768 hands has the same
+  # hand value, or score.
+  #
+  # This exercise demonstrates that the number of unique hands (that is, hands that share an identical
+  # hand score) is significantly lower than the number of distinct hands. This is because card suits
+  # don’t tend to affect the score of a hand  (the only exception being a flush).
+  #
+  # This method carries the same semantics as the list method, but returns unique hands instead of
+  # every possible hand.
+  def list_unique arguments=nil
+    results = list arguments
+    return results if results.nil? || results.size == 0
+
+    hash = Hash.new
+    results.each do |result|
+      hash[result.hash_key] = result
+    end
+    hash.values
+  end
+
+  private
+
+  def hands
+    if @hands.empty?
+      Deck.new.combination(5).each {|cards| @hands << Hand.new(cards)}
+    end
+    @hands
+  end
+
+end

data/lib/rora/repository/starting_hand_repository.rb

@@ -0,0 +1,23 @@
+class StartingHandRepository
+  include Singleton
+  attr_reader :all, :distinct
+
+  def initialize
+    @all = Array.new
+    @distinct = Hash.new
+    Deck.new.cards.combination(2) do |combination|
+      starting_hand = StartingHand.new(combination)
+      @all << starting_hand
+      @distinct[starting_hand.key] = starting_hand
+    end
+  end
+
+  def all_starting_hands
+    @all
+  end
+
+  def distinct_starting_hands
+    @distinct.values
+  end
+
+end

data/lib/rora.rb

@@ -0,0 +1,12 @@
+require 'rora/model/board'
+require 'rora/model/card'
+require 'rora/model/deck'
+require 'rora/model/hand'
+require 'rora/model/hand_type'
+require 'rora/model/pot'
+require 'rora/model/rank'
+require 'rora/model/starting_hand'
+require 'rora/model/suit'
+
+require 'rora/repository/hand_repository'
+require 'rora/repository/starting_hand_repository'

data/test/rora/model/board_test.rb

@@ -0,0 +1,137 @@
+require File.expand_path("../../rora_test", File.dirname(__FILE__))
+
+class BoardTest < ActiveSupport::TestCase
+
+  test "should raise an error when a board is created with less than 3 cards" do
+    assert_raise ArgumentError do
+      Board.new "AS,KS"
+    end
+  end
+
+  test "should raise an error when a board is created with more than 5 cards" do
+    assert_raise ArgumentError do
+      Board.new "AS,KS,QS,JS,TS,9S"
+    end
+  end
+
+  test "should raise an error when a board is created with duplicate cards" do
+    assert_raise ArgumentError do
+      Board.new "AS KS JS AS KS"
+    end
+  end
+
+  test "should have an empty board if the board was not initialized with cards" do
+    assert_equal 0, Board.new.cards.size
+  end
+
+  test "the board should have three cards if the board was initialized with the flop" do
+    assert_equal 3, Board.new("AS,KS,QS").cards.size
+  end
+
+  test "the board should have four cards if the board was initialized with the flop and turn" do
+    assert_equal 4, Board.new("AS,KS,QS,JS").cards.size
+  end
+
+  test "the board should have five cards if the board was initialized with the flop, turn and river" do
+    assert_equal 5, Board.new("AS,KS,QS,JS,TS").cards.size
+  end
+
+  test "should raise an error when a flop is not created with 3 cards" do
+    assert_raise ArgumentError do
+      Board.new.flop "AS,KS"
+    end
+  end
+
+  test "should raise an error when a flop is set with duplicate cards" do
+    assert_raise ArgumentError do
+      Board.new.flop "AS AS JS"
+    end
+  end
+
+  test "should raise an error when a flop is set with no cards" do
+    assert_raise ArgumentError do
+      Board.new.flop []
+    end
+  end
+
+  test "should have a board with three cards after the flop is dealt" do
+    board = Board.new
+    board.flop = "AS KS QS"
+    assert_equal 3, board.cards.size
+    assert_equal board.flop, board.cards
+  end
+
+  test "should raise an error when a turn card is dealt before the flop has been dealt" do
+    assert_raise RuntimeError do
+      board = Board.new
+      board.turn = "AS"
+    end
+  end
+
+  test "should raise an error when the turn card has already been dealt" do
+    assert_raise ArgumentError do
+      board = Board.new
+      board.flop= "AS,AH,AD"
+      board.turn= "AH"
+    end
+  end
+
+  test "should have a board with four cards after the turn card is dealt" do
+    board = Board.new
+    board.flop = "AS KS QS"
+    board.turn = "JS"
+    assert_equal 4, board.cards.size
+    assert_equal Card.new("JS"), board.turn
+  end
+
+  test "should raise an error when the river card is dealt before the turn card has been dealt" do
+    assert_raise RuntimeError do
+      board = Board.new
+      board.flop = "AS KS QS"
+      board.river = "JS"
+    end
+  end
+
+  test "should raise an error when the river card has already been dealt" do
+    assert_raise ArgumentError do
+      board = Board.new
+      board.flop = "AS,KS,QS"
+      board.turn = "JS"
+      board.river = "AS"
+    end
+  end
+
+  test "should have a board with five cards after the river card is dealt" do
+    board = Board.new
+    board.flop = "AS KS QS"
+    board.turn = "JS"
+    board.river = "TS"
+    assert_equal 5, board.cards.size
+    assert_equal Card.new("TS"), board.river
+  end
+
+  test "should return false if the board does not contain the given card" do
+    board = Board.new "AS,KS,QS,JS,TS"
+    assert_equal false, board.contains?("3D")
+    assert_equal false, board.contains?(Card.new("3D"))
+  end
+
+  test "should return true if the boad does contain the given card" do
+    board = Board.new "AS,KS,QS,JS,TS"
+    assert_equal true, board.contains?("TS")
+    assert_equal true, board.contains?(Card.new("AS"))
+  end
+
+  test "should return false if the board does not contain any of the given cards" do
+    board = Board.new "AS,KS,QS,JS,TS"
+    assert_equal false, board.contains_any?(Card.to_cards("AH,KH,QH"))
+    assert_equal false, board.contains_any?("AH,KH,QH")
+  end
+
+  test "should return true if the board contains at least one of the given cards" do
+    board = Board.new "AS,KS,QS,JS,TS"
+    assert_equal true, board.contains_any?(Card.to_cards("AH,KH,QH,JH,KS"))
+    assert_equal true, board.contains_any?("AH,KH,QH,JH,KS")
+  end
+
+end

data/test/rora/model/card_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../../rora_test", File.dirname(__FILE__))
+
+class CardTest < ActiveSupport::TestCase
+
+  test "should be able to create a card with the specified rank and suit" do
+    card = Card.new(Rank::ACE, Suit::SPADE)
+    assert_equal card.rank, Rank::ACE
+    assert_equal card.suit, Suit::SPADE
+  end
+
+  test "should be able to create a card with the specified string value" do
+    card = Card.new("AS")
+    assert_equal card.rank, Rank::ACE
+    assert_equal card.suit, Suit::SPADE
+  end
+
+  test "should raise an exception when attempting to create a card with an invalid string value" do
+    assert_raise ArgumentError do
+      card = Card.new("A")
+    end
+  end
+
+  test "a card id should be equal to the product of the card suit id and rank id" do
+    card = Card.new(Rank::ACE, Suit::SPADE)
+    assert_equal card.id, (Rank::ACE.id * Suit::SPADE.id)
+  end
+
+  test "a card value should be equal to the concatenation of the card suit value and rank value" do
+    card = Card.new(Rank::ACE, Suit::SPADE)
+    assert_equal card.value, (Rank::ACE.value + Suit::SPADE.value)
+  end
+
+  test "a card key should be equal to the concatenation of the card suit key and rank key" do
+    assert_equal "AS", Card.new("AS").key
+  end
+
+  test "a card should have a name" do
+    assert_equal "Ace of Spades", Card.new("AS").name
+  end
+
+  test "should generate a readable string representation" do
+    assert_equal "Card: name='Ace of Spades' value='AS' id=1927", Card.new("AS").to_s
+  end
+
+  test "should convert an arbitrarily long string of characters into an array of cards" do
+    assert_equal 7, Card.to_cards("ASKSJSQSTCJCAH").size
+  end
+
+  test "should convert an arbitrarily long string of comma-delimited characters into an array of cards" do
+    assert_equal 7, Card.to_cards("AS,KS,JS,QS,TC,JC,AH").size
+  end
+
+  test "should convert an arbitrarily long string of space-delimited characters into an array of cards" do
+    assert_equal 7, Card.to_cards("AS KS JS QS TC JC AH").size
+  end
+
+end

data/test/rora/model/deck_test.rb

@@ -0,0 +1,114 @@
+require File.expand_path("../../rora_test", File.dirname(__FILE__))
+
+class DeckTest < ActiveSupport::TestCase
+
+  def setup
+    @deck = Deck.new
+    @card = Card.new("AS")
+  end
+
+  test "a deck should contain 52 cards" do
+    assert_equal 52, @deck.size
+  end
+
+  test "a deck should not be empty" do
+    assert_equal false, @deck.empty?
+  end
+
+  test "a deck should be empty after all 52 cards have been dealt" do
+    52.times { @deck.deal }
+    assert_equal true, @deck.empty?
+  end
+
+  test "a deck should contain 4 cards of each rank" do
+    assert_equal 4, @deck.count_cards_with_rank(Rank::ACE)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::KING)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::QUEEN)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::JACK)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::TEN)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::NINE)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::EIGHT)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::SEVEN)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::SIX)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::FIVE)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::FOUR)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::THREE)
+    assert_equal 4, @deck.count_cards_with_rank(Rank::TWO)
+  end
+
+  test "a deck should contain 13 cards of each suit" do
+    assert_equal 13, @deck.count_cards_with_suit(Suit::CLUB)
+    assert_equal 13, @deck.count_cards_with_suit(Suit::DIAMOND)
+    assert_equal 13, @deck.count_cards_with_suit(Suit::HEART)
+    assert_equal 13, @deck.count_cards_with_suit(Suit::SPADE)
+  end
+
+  test "should return a shallow copy of cards" do
+    assert_equal 52, @deck.size
+    @deck.cards.delete_at(0)
+    assert_equal 52, @deck.size
+  end
+
+  test "should shuffle the cards in a deck" do
+    before = @deck.cards[0]
+    @deck.shuffle
+    after = @deck.cards[0]
+    assert_not_equal before, after
+  end
+
+  test "should remove a card from the deck" do
+    assert_equal 52, @deck.size
+    @deck.remove @card
+    assert_equal 51, @deck.size
+    @deck.remove @card
+    assert_equal 51, @deck.size
+  end
+
+  test "should remove multiple cards from the deck" do
+    cards = [Card.new("QS"), Card.new("KS"), Card.new("AS")]
+
+    assert_equal 52, @deck.size
+    @deck.remove cards
+    assert_equal 49, @deck.size
+    @deck.remove cards
+    assert_equal 49, @deck.size
+  end
+
+  test "should remove a starting hand from the deck" do
+    assert_equal 52, @deck.size
+    @deck.remove StartingHand.new("ASKS")
+    assert_equal 50, @deck.size
+  end
+
+  test "should remove card values from the deck" do
+    assert_equal 52, @deck.size
+    @deck.remove "AS"
+    assert_equal 51, @deck.size
+    @deck.remove "KS,QS"
+    assert_equal 49, @deck.size
+  end
+
+  test "should determine if the given card is in the deck" do
+    assert_equal true, @deck.contains?(@card)
+    @deck.remove(@card)
+    assert_equal false, @deck.contains?(@card)
+  end
+
+  test "should deal a card from the deck" do
+    card = @deck.deal
+    assert_not_nil card
+    assert_equal 51, @deck.size
+  end
+
+  test "should return false if the board does not contain any of the given cards" do
+    @deck.remove "AH,KH,QH,JS,TS"
+    assert_equal false, @deck.contains_any?(Card.to_cards("AH,KH,QH"))
+    assert_equal false, @deck.contains_any?("AH,KH,QH")
+  end
+
+  test "should return true if the board contains at least one of the given cards" do
+    assert_equal true, @deck.contains_any?(Card.to_cards("AH,KH,QH,JH,KS"))
+    assert_equal true, @deck.contains_any?("AH,KH,QH,JH,KS")
+  end
+
+end

data/test/rora/model/hand_test.rb

@@ -0,0 +1,91 @@
+require File.expand_path("../../rora_test", File.dirname(__FILE__))
+
+class HandTest < ActiveSupport::TestCase
+
+  def setup
+    @hand = Hand.new("AS,KS,QS,JS,TS")
+  end
+
+  test "should raise an error when a hand is not created with 5 cards" do
+    assert_raise ArgumentError do
+      Hand.new [Card.new("AS"), Card.new("KS")]
+    end
+  end
+
+  test "should raise an error when a hand is not created with 10 characters" do
+    assert_raise ArgumentError do
+      Hand.new "ASKSQSJS"
+    end
+  end
+
+  test "should raise an error when creating a hand with duplicate cards" do
+    assert_raise ArgumentError do
+      Hand.new "AS KS JS AS KS"
+    end
+  end
+
+  test "the hand should have an id" do
+    assert_equal 7193866898674063, @hand.id
+  end
+
+  test "the hand id should be equal to the product of each card id contained in the hand" do
+    assert_equal @hand.id, (Card.new("AS").id * Card.new("KS").id * Card.new("QS").id * Card.new("JS").id * Card.new("TS").id)
+  end
+
+  test "the hand should have a hash key" do
+    assert_equal 2101589603, @hand.hash_key
+  end
+
+  test "the hash key should be equal to the product of each card rank id in the hand times" do
+    assert_equal Hand.new("ASACAHJSTS").hash_key, (Card.new("AS").rank.id * Card.new("AC").rank.id * Card.new("AH").rank.id * Card.new("JS").rank.id * Card.new("TS").rank.id)
+  end
+
+  test "the hash key should be equal to the product of each card rank id in the hand times 67 when the hand is a flush" do
+    assert_equal @hand.hash_key, (Card.new("AS").rank.id * Card.new("KS").rank.id * Card.new("QS").rank.id * Card.new("JS").rank.id * Card.new("TS").rank.id * 67)
+  end
+
+  test "the hand should have a value" do
+    assert_equal "AS,KS,QS,JS,TS", @hand.value
+  end
+
+  test "the hand should be a flush" do
+    assert_equal true, @hand.flush?
+  end
+
+  test "the hand should not be a flush" do
+    assert_equal false, Hand.new("2D3S4H8CJS").flush?
+  end
+
+  test "the hand should have a score" do
+    assert_equal 1, @hand.score
+  end
+
+  test "the hand should have a probability" do
+    assert_equal 0.0015, @hand.probability
+  end
+
+  test "the hand should have a name" do
+    assert_equal "Royal Flush", @hand.name
+  end
+
+  test "the hand should have a hand type" do
+    assert_equal HandType::STRAIGHT_FLUSH, @hand.type
+  end
+
+  test "the hand should have five cards" do
+    assert_equal 5, @hand.cards.size
+  end
+
+  test "the hand should be a straight flush" do
+    assert_equal true, @hand.straight_flush?
+  end
+
+  test "the hand should be a straight" do
+    assert_equal true, Hand.new("ACKSQSJDTS").straight?
+  end
+
+  test "the hand should be a four of a kind" do
+    assert_equal true, Hand.new("ACASAHADJS").four_of_a_kind?
+  end
+
+end

data/test/rora/model/hand_type_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path("../../rora_test", File.dirname(__FILE__))
+
+class HandTypeTest < ActiveSupport::TestCase
+
+  test "should return all hand types" do
+    assert_equal 9, HandType.values.size
+  end
+
+  test "should return the correct hand type for the given key" do
+    assert_equal HandType::HIGH_CARD, HandType.get("HC")
+  end
+
+  test "should perform a case insensitive key lookup" do
+    assert_equal(HandType::HIGH_CARD, HandType.get("Hc"))
+  end
+
+  test "should raise an error when performing a lookup with an invalid key" do
+    assert_raise ArgumentError do
+      HandType.get("L")
+    end
+  end
+
+  test "should raise an error when performing a lookup with an empty key" do
+    assert_raise ArgumentError do
+      HandType.get("")
+    end
+  end
+
+  test "should raise an error when performing a lookup with a nil key" do
+    assert_raise TypeError do
+      HandType.get(nil)
+    end
+  end
+
+  test "should generate a readable string representation" do
+    assert_equal "HandType: key='FL', value='Flush'", HandType::FLUSH.to_s
+  end
+
+end

data/test/rora/model/pot_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path("../../rora_test", File.dirname(__FILE__))
+
+class PotTest < ActiveSupport::TestCase
+
+  test "a new post should have a total of 0 dollars" do
+    assert_equal 0, Pot.new.total
+  end
+
+  test "should be able to add money to the pot" do
+    pot = Pot.new.add 5
+    assert_equal 5, pot.total
+  end
+
+  test "should be able to add money with decimals to the pot" do
+    pot = Pot.new.add 5.75
+    assert_equal 5.75, pot.total
+  end
+
+  test "should be able to perform compound addtion operations" do
+    pot = Pot.new.add(2).add(2.25).add(2)
+    assert_equal 6.25, pot.total
+  end
+
+  test "should return a string representation of the pot" do
+    assert_equal "Pot: $300.00", Pot.new().add(300.00).to_s
+  end
+
+end