acpc_poker_types 7.4.4 → 7.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc054363106e9a2afe77f03a05842fcfeeb93c01
-  data.tar.gz: 3670d50e64a9c4b9bda0f2f694861a4705308636
+  metadata.gz: 24b1ae84329dfaa9dac79bbfb0cba092682f68b9
+  data.tar.gz: 32a4f028764cdf4bae820490b3dbc6d840404652
 SHA512:
-  metadata.gz: 7048866cb708cbc6099c44940153de05d1244c79238964f17156afbd71c5ce2ecb82bc3b7a2cdb3fd166faf4a5c2ce54d9c917f473533674ee385b55445ca9a6
-  data.tar.gz: f9a203d6ad583c7857b3a3029a0b8601792331496a5a92274f06534d90bed1537db5f5499d17790175cf0dc2bb9f546c718ef0d8ec56c9b2029331fa003bd025
+  metadata.gz: 02df0c4f20beb7e2748f7bb87afafc693743d05759f5282ceb8ec8c4e5b3d9fa78360382d3cfaa2eae8ab37c1dfc7c45808b5543f12e597cfbd833f143080cb2
+  data.tar.gz: 83df022f017169e0b0085624c88506d36b298c92b2f8a8a547fe42bf310ae35227036d4a89e9281705c30d4cdfc908d3ce95b3a947bb3d82b06f49e619ade610

data/acpc_poker_types.gemspec

@@ -15,12 +15,13 @@ Gem::Specification.new do |s|
   s.add_dependency 'acpc_dealer', '~> 2.0'
   s.add_dependency 'celluloid', '~> 0.14'
   s.add_dependency 'contextual_exceptions', '~> 0.0'
+  s.add_dependency 'inflections', '~> 3.2'
 
   s.files         = Dir.glob("lib/**/*") + %w(Rakefile acpc_poker_types.gemspec README.md)
   s.test_files    = Dir.glob "spec/**/*"
   s.require_paths = ["lib"]
 
-  s.add_development_dependency 'minitest', '~> 5.0.6'
+  s.add_development_dependency 'minitest', '~> 5.5'
   s.add_development_dependency 'mocha', '~> 0.13'
   s.add_development_dependency 'awesome_print', '~> 1.0'
   s.add_development_dependency 'simplecov', '~> 0.7'

data/lib/acpc_poker_types.rb

@@ -14,4 +14,76 @@ require "acpc_poker_types/dealer_data"
 require 'acpc_poker_types/seat'
 
 module AcpcPokerTypes
+  # @todo Functionality (but not implementation) duplicated
+  # from AcpcPokerTypes::PlayersAtTheTable
+  def dealer_index(hand_number, game_def)
+    (hand_number + game_def.number_of_players - 1) % game_def.number_of_players
+  end
+  def big_blind_payer_index(hand_number, game_def)
+    (hand_number + game_def.blinds.index(game_def.blinds.max)) % game_def.number_of_players
+  end
+  def small_blind_payer_index(hand_number, game_def)
+    (hand_number + game_def.blinds.index(game_def.blinds.min)) % game_def.number_of_players
+  end
+
+  def check_description(player)
+    "#{player} checks"
+  end
+  def call_description(player, poker_action)
+    "#{player} calls (#{poker_action.cost.to_i})"
+  end
+  def bet_description(player, poker_action)
+    d = "#{player} bets"
+    if poker_action.modifier
+      d + " by #{poker_action.cost.to_i} to #{poker_action.modifier}"
+    else
+      d
+    end
+  end
+  def limit_raise_description(
+    player,
+    poker_action,
+    num_wagers_so_far,
+    max_num_wagers
+  )
+    "#{player} calls and raises (##{num_wagers_so_far+1} of #{max_num_wagers})"
+  end
+  def no_limit_raise_description(player, poker_action, amount_to_call)
+    "#{player} calls (#{amount_to_call}) and raises by #{poker_action.cost.to_i} to #{poker_action.modifier}"
+  end
+  def fold_description(player)
+    "#{player} folds"
+  end
+  def hand_dealt_description(players, hand_number, game_def, number_of_hands)
+    raise unless players.length == game_def.number_of_players
+    big_blind_payer = players[big_blind_payer_index(
+      hand_number,
+      game_def
+    )]
+    small_blind_payer = players[small_blind_payer_index(
+      hand_number,
+      game_def
+    )]
+    dealer_player = players[dealer_index(
+      hand_number,
+      game_def
+    )]
+    "Hand ##{hand_number} of #{number_of_hands} dealt by #{dealer_player}, #{small_blind_payer} pays SB (#{game_def.blinds.min}), #{big_blind_payer} pays BB (#{game_def.blinds.max})"
+  end
+  def hand_win_description(player, amount_won, current_balance)
+    "#{player} wins #{amount_won}, bringing their balance to #{current_balance + amount_won}"
+  end
+  def split_pot_description(players, amount)
+    a = if players.length > 2
+      players[0..-2].join(', ') + ", and #{players.last}"
+    else
+      "#{players[0]} and #{players[1]}"
+    end
+    split_amount = (amount / players.length.to_r).round(2)
+    "#{a} split the pot, each winning " + if split_amount == split_amount.to_i
+        split_amount.to_i.to_s
+      else
+        sprintf("%0.2f", split_amount.to_f)
+      end
+  end
 end

data/lib/acpc_poker_types/pile_of_cards.rb

@@ -1,11 +1,199 @@
-
 require 'hand_evaluator'
+require 'inflections'
+require 'active_support'
 
 module AcpcPokerTypes
   class PileOfCards < Array
+    POKER_HAND_STRENGTHS = {
+      royal_flush: 12115,
+      straight_flush: 12106,
+      four_of_a_kind: 11934,
+      full_house: 10921,
+      flush: 9634,
+      straight: 9623,
+      three_of_a_kind: 8606,
+      two_pair: 5291,
+      one_pair: 1287,
+      high_card: 0
+    }
+
     # @return [Integer] The strength of the strongest poker hand that can be made from this pile of cards.
     def to_poker_hand_strength
       HandEvaluator.rank_hand map { |card| card.to_i }
     end
+
+    def to_poker_hand_key
+      flattened_strengths = self.class().poker_hand_strengths_sorted_desc.flatten
+      flattened_strengths[
+        flattened_strengths.index do |e|
+          e.respond_to?(:to_i) && e.to_i <= to_poker_hand_strength
+        end - 1
+      ]
+    end
+
+    def to_poker_hand_description
+      case to_poker_hand_key
+      when :royal_flush
+        'royal flush'
+      when :straight_flush
+        "#{Rank.new(to_poker_hand_strength - POKER_HAND_STRENGTHS[:straight_flush] + 3).to_sym}-high straight flush"
+      when :four_of_a_kind
+        rank_with_quad = largest_rank(4)
+
+        m = "quad #{ActiveSupport::Inflector.pluralize(rank_with_quad.to_sym.to_s)}"
+
+        if length > 4
+          kicker = remaining_cards(rank_with_quad, 4).largest_rank
+          "#{m} with #{kicker.to_sym} kicker"
+        else
+          m
+        end
+      when :full_house
+        rank_with_trip = largest_rank(3)
+        rank_with_pair = remaining_cards(rank_with_trip, -1).largest_rank 2
+        "#{ActiveSupport::Inflector.pluralize(rank_with_trip.to_sym.to_s)} full of #{ActiveSupport::Inflector.pluralize(rank_with_pair.to_sym.to_s)}"
+      when :flush
+        flush_with_largest_rank = nil
+        largest_rank_so_far = -1
+        Suit.every_suit do |suit|
+          if count { |c| c.suit == suit } >= 5
+            r = largest_rank 1, [suit]
+            if r > largest_rank_so_far
+              flush_with_largest_rank = suit
+              largest_rank_so_far = r
+            end
+          end
+        end
+        cards = all_cards flush_with_largest_rank
+        r1 = cards.largest_rank
+        cards = cards.remaining_cards(r1)
+        r2 = cards.largest_rank
+        cards = cards.remaining_cards(r2)
+        r3 = cards.largest_rank
+        cards = cards.remaining_cards(r3)
+        r4 = cards.largest_rank
+        cards = cards.remaining_cards(r4)
+        r5 = cards.largest_rank
+
+        "#{r1.to_sym}, #{r2.to_sym}, #{r3.to_sym}, #{r4.to_sym}, #{r5.to_sym} flush"
+      when :straight
+        "#{Rank.new(to_poker_hand_strength - POKER_HAND_STRENGTHS[:straight] + 3).to_sym}-high straight"
+      when :three_of_a_kind
+        r = largest_rank 3
+        m = "trip #{ActiveSupport::Inflector.pluralize(r.to_sym.to_s)}"
+
+        if length > 3
+          cards = remaining_cards(r, 3)
+          r1 = cards.largest_rank
+          m += " with #{r1.to_sym}"
+
+          if length > 4
+            cards = cards.remaining_cards r1
+            r2 = cards.largest_rank
+            m += " and #{r2.to_sym}"
+          end
+        end
+        m
+      when :two_pair
+        first_pair = largest_rank 2
+        cards = remaining_cards first_pair, -1
+        second_pair = cards.largest_rank 2
+
+        m = "#{ActiveSupport::Inflector.pluralize(first_pair.to_sym.to_s)} and #{ActiveSupport::Inflector.pluralize(second_pair.to_sym.to_s)}"
+
+        if length > 4
+          cards = cards.remaining_cards second_pair, -1
+          "#{m} with #{cards.largest_rank.to_sym} kicker"
+        else
+          m
+        end
+      when :one_pair
+        pair = largest_rank 2
+
+        m = "pair of #{ActiveSupport::Inflector.pluralize(pair.to_sym.to_s)}"
+
+        if length > 2
+          cards = remaining_cards pair, -1
+          r1 = cards.largest_rank
+          m += " with #{r1.to_sym}"
+
+          if length > 3
+            cards = cards.remaining_cards r1, -1
+            r2 = cards.largest_rank
+
+            if length > 4
+              cards = cards.remaining_cards r2, -1
+              r3 = cards.largest_rank
+              m += ", #{r2.to_sym}, and #{r3.to_sym}"
+            else
+              m += " and #{r2.to_sym}"
+            end
+          end
+        end
+        m
+      when :high_card
+        cards = self
+        hand = [5, length].min.times.inject([]) do |h, i|
+          c = cards.largest_rank
+          h << c.to_sym
+          cards = cards.remaining_cards(c, -1)
+          h
+        end
+
+        if length == 1
+          "#{hand.first}"
+        elsif length == 2
+          "#{hand.first} and #{hand.last}"
+        else
+          "#{hand[0..-2].join(', ')}, and #{hand.last}"
+        end
+      end
+    end
+
+    def all_cards(suit)
+      self.class().new(select { |c| c.suit == suit })
+    end
+
+    def remaining_cards(
+      rank_of_cards_to_remove,
+      number_of_cards_to_remove = 1
+    )
+      num_matched_cards = 0
+      reduce(self.class().new([])) do |cards, c|
+        if (
+          c.rank == rank_of_cards_to_remove && (
+            num_matched_cards < number_of_cards_to_remove ||
+            number_of_cards_to_remove < 0
+          )
+        )
+          num_matched_cards += 1
+        else
+          cards << c
+        end
+        cards
+      end
+    end
+
+    def largest_rank(number_of_cards = 1, suits = Suit.all_suits)
+      rank = -1
+      each do |card|
+        if (
+          card.rank > rank &&
+          suits.include?(card.suit) &&
+          count { |c| c.rank == card.rank } >= number_of_cards &&
+          card.rank > rank
+        )
+          rank = card.rank
+        end
+      end
+      rank
+    end
+
+    private
+
+    # @return [Array<Array<Symbol,Integer>>]
+    def self.poker_hand_strengths_sorted_desc
+      POKER_HAND_STRENGTHS.sort { |a, b| b.last <=> a.last }
+    end
   end
 end

data/lib/acpc_poker_types/rank.rb

@@ -3,6 +3,8 @@ using ContextualExceptions::ClassRefinement
 
 module AcpcPokerTypes
   class Rank
+    include Comparable
+
     exceptions :unrecognized_rank
 
     DOMAIN = {
@@ -47,6 +49,10 @@ module AcpcPokerTypes
       @symbol = AcpcPokerTypes::Rank.symbol_from_rank_token rank
     end
 
+    def <=>(rank)
+      self.to_i <=> rank.to_i
+    end
+
     def to_sym
       @symbol
     end

data/lib/acpc_poker_types/suit.rb

@@ -3,6 +3,8 @@ using ContextualExceptions::ClassRefinement
 
 module AcpcPokerTypes
   class Suit
+    include Comparable
+
     exceptions :unrecognized_suit
 
     DOMAIN = {
@@ -12,6 +14,18 @@ module AcpcPokerTypes
       spades: {acpc_character: 's', html_character: '♠', number: 3}
     }
 
+    def self.all_suits
+      DOMAIN.map do |suit, properties|
+        Suit.new(suit)
+      end
+    end
+
+    def self.every_suit
+      DOMAIN.each do |suit, properties|
+        yield Suit.new(suit)
+      end
+    end
+
     def self.hash_from_suit_token(suit)
       if suit.kind_of?(Integer)
         DOMAIN.find do |suit_symbol, properties|
@@ -38,6 +52,10 @@ module AcpcPokerTypes
       @symbol = AcpcPokerTypes::Suit.symbol_from_suit_token suit
     end
 
+    def <=>(suit)
+      self.to_i <=> suit.to_i
+    end
+
     def to_sym
       @symbol
     end

data/lib/acpc_poker_types/version.rb

@@ -1,3 +1,3 @@
 module AcpcPokerTypes
-  VERSION = '7.4.4'
+  VERSION = '7.5.0'
 end

data/spec/acpc_poker_types_spec.rb

@@ -0,0 +1,155 @@
+require_relative 'support/spec_helper.rb'
+require_relative '../lib/acpc_poker_types.rb'
+
+include AcpcPokerTypes
+
+describe AcpcPokerTypes do
+  before do
+    @l_game_def = GameDefinition.parse(
+      '
+GAMEDEF
+limit
+numPlayers = 2
+numRounds = 4
+blind = 10 5
+raiseSize = 10 10 20 20
+firstPlayer = 2 1 1 1
+maxRaises = 3 4 4 4
+numSuits = 4
+numRanks = 13
+numHoleCards = 2
+numBoardCards = 0 3 1 1
+END GAMEDEF
+      '.split("\n")
+    )
+    @nl_game_def = GameDefinition.parse(
+      '
+GAMEDEF
+nolimit
+numPlayers = 2
+numRounds = 4
+stack = 20000 20000
+blind = 100 50
+firstPlayer = 2 1 1 1
+numSuits = 4
+numRanks = 13
+numHoleCards = 2
+numBoardCards = 0 3 1 1
+END GAMEDEF
+      '.split("\n")
+    )
+  end
+
+  it 'when player A calls a bet of 100 the log would say: A calls (100)' do
+    call_description(
+      'A',
+      PokerAction.new('c', cost: 100)
+    ).must_equal 'A calls (100)'
+  end
+
+  describe "no-limit hold'em" do
+    it 'when player A bets by 500 to 700: A bets by 500 to 700' do
+      bet_description(
+        'A',
+        PokerAction.new('b700', cost: 500)
+      ).must_equal 'A bets by 500 to 700'
+    end
+    it 'when player B raises by 500 to 700 after player A bet by 100 to 200: B calls (100) and raises by 500 to 700' do
+      no_limit_raise_description(
+        'B',
+        PokerAction.new('r700', cost: 500),
+        100
+      ).must_equal 'B calls (100) and raises by 500 to 700'
+    end
+  end
+
+  describe "limit hold'em" do
+    it 'when player A bets: A bets' do
+      bet_description(
+        'A',
+        PokerAction.new('b', cost: 500)
+      ).must_equal 'A bets'
+    end
+    it 'when player B raises after player A bet in a round with a maximum of four wagers: B calls and raises (#2 of 4)' do
+      limit_raise_description(
+        'B',
+        PokerAction.new('r', cost: 500),
+        1,
+        4
+      ).must_equal 'B calls and raises (#2 of 4)'
+    end
+  end
+
+  it 'when player A checks: A checks' do
+    check_description('A').must_equal 'A checks'
+  end
+  it 'when player A folds: A folds' do
+    fold_description('A').must_equal 'A folds'
+  end
+  it 'when the xth hand is dealt by player A, and A is small blind, while player B is big blind: Hand #x of y dealt by A, A pays SB (5), B pays BB (10)' do
+    x = 23
+    y = 100
+    p1 = 'A'
+    p2 = 'B'
+    hand_dealt_description(
+      [p1, p2],
+      x,
+      @l_game_def,
+      y
+    ).must_equal "Hand ##{x} of #{y} dealt by #{p1}, #{p1} pays SB (#{@l_game_def.blinds.min}), #{p2} pays BB (#{@l_game_def.blinds.max})"
+  end
+
+  describe 'hand result messages' do
+    it 'when player A wins 1000 to increase their balance to 2000: A wins 1000, bringing their balance to 2000' do
+      player = 'A'
+      amount_won = 1000
+      current_balance = 2000
+      hand_win_description(
+        player,
+        amount_won,
+        current_balance
+      ).must_equal "#{player} wins #{amount_won}, bringing their balance to #{current_balance + amount_won}"
+    end
+
+    describe '#split_pot_description' do
+      it 'when players A and B split the bot of 1000: A and B split the pot, each winning 500' do
+        split_pot_description(
+          ['A', 'B'],
+          1000
+        ).must_equal 'A and B split the pot, each winning 500'
+      end
+
+      it 'when players A, B, and C split the bot of 1000: A, B, and C split the pot, each winning 333.' do
+        split_pot_description(
+          ['A', 'B', 'C'],
+          1000
+        ).must_equal 'A, B, and C split the pot, each winning 333.33'
+      end
+    end
+  end
+
+  describe '#dealer_index, #big_blind_payer_index, and #small_blind_payer_index' do
+    it 'should return the index of the big blind on the first hand' do
+      dealer_index(0, @l_game_def).must_equal 1
+      big_blind_payer_index(0, @l_game_def).must_equal 0
+      small_blind_payer_index(0, @l_game_def).must_equal 1
+    end
+    it 'should work on every other hand' do
+      dealer_index(1, @l_game_def).must_equal 0
+      big_blind_payer_index(1, @l_game_def).must_equal 1
+      small_blind_payer_index(1, @l_game_def).must_equal 0
+      dealer_index(2, @l_game_def).must_equal 1
+      big_blind_payer_index(2, @l_game_def).must_equal 0
+      small_blind_payer_index(2, @l_game_def).must_equal 1
+      dealer_index(3, @l_game_def).must_equal 0
+      big_blind_payer_index(3, @l_game_def).must_equal 1
+      small_blind_payer_index(3, @l_game_def).must_equal 0
+      dealer_index(4, @l_game_def).must_equal 1
+      big_blind_payer_index(4, @l_game_def).must_equal 0
+      small_blind_payer_index(4, @l_game_def).must_equal 1
+      dealer_index(5, @l_game_def).must_equal 0
+      big_blind_payer_index(5, @l_game_def).must_equal 1
+      small_blind_payer_index(5, @l_game_def).must_equal 0
+    end
+  end
+end

data/spec/pile_of_cards_spec.rb

@@ -3,10 +3,10 @@
 require File.expand_path('../support/spec_helper', __FILE__)
 
 require 'hand_evaluator'
-require 'acpc_poker_types/card'
-require 'acpc_poker_types/pile_of_cards'
-require 'acpc_poker_types/rank'
-require 'acpc_poker_types/suit'
+require_relative '../lib/acpc_poker_types/card'
+require_relative '../lib/acpc_poker_types/pile_of_cards'
+require_relative '../lib/acpc_poker_types/rank'
+require_relative '../lib/acpc_poker_types/suit'
 
 describe AcpcPokerTypes::PileOfCards do
   describe '#to_poker_hand_strength' do
@@ -39,12 +39,508 @@ describe AcpcPokerTypes::PileOfCards do
 
       patient.to_poker_hand_strength.must_equal hand_strength
     end
+  end
+
+  describe '#to_poker_hand_description' do
+    it 'works for royal flush' do
+      AcpcPokerTypes::PileOfCards.new(
+        [
+          AcpcPokerTypes::Card.from_acpc('Ah'),
+          AcpcPokerTypes::Card.from_acpc('Kh'),
+          AcpcPokerTypes::Card.from_acpc('Qh'),
+          AcpcPokerTypes::Card.from_acpc('Jh'),
+          AcpcPokerTypes::Card.from_acpc('Th'),
+          AcpcPokerTypes::Card.from_acpc('2s'),
+          AcpcPokerTypes::Card.from_acpc('5c')
+        ]
+      ).to_poker_hand_key.must_equal(:royal_flush)
+    end
+    describe 'straight flush' do
+      it 'works for the smallest straight flush' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('5h'),
+            AcpcPokerTypes::Card.from_acpc('4h'),
+            AcpcPokerTypes::Card.from_acpc('3h'),
+            AcpcPokerTypes::Card.from_acpc('2h'),
+            AcpcPokerTypes::Card.from_acpc('Ah'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:straight_flush)
+      end
+      it 'works for a larger straight flush' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Th'),
+            AcpcPokerTypes::Card.from_acpc('9h'),
+            AcpcPokerTypes::Card.from_acpc('8h'),
+            AcpcPokerTypes::Card.from_acpc('7h'),
+            AcpcPokerTypes::Card.from_acpc('6h'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:straight_flush)
+      end
+    end
+    describe 'four of a kind' do
+      it 'works for the smallest four of a kind' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2h'),
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('2d'),
+            AcpcPokerTypes::Card.from_acpc('2s')
+          ]
+        ).to_poker_hand_key.must_equal(:four_of_a_kind)
+      end
+      it 'works for a larger four of a kind' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Th'),
+            AcpcPokerTypes::Card.from_acpc('Tc'),
+            AcpcPokerTypes::Card.from_acpc('Td'),
+            AcpcPokerTypes::Card.from_acpc('Ts'),
+            AcpcPokerTypes::Card.from_acpc('6h'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:four_of_a_kind)
+      end
+    end
+    describe 'full house' do
+      it 'works for the smallest full house' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2h'),
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('2d'),
+            AcpcPokerTypes::Card.from_acpc('3s'),
+            AcpcPokerTypes::Card.from_acpc('3h'),
+            AcpcPokerTypes::Card.from_acpc('6s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:full_house)
+      end
+      it 'works for a larger full house' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Th'),
+            AcpcPokerTypes::Card.from_acpc('Tc'),
+            AcpcPokerTypes::Card.from_acpc('Td'),
+            AcpcPokerTypes::Card.from_acpc('6s'),
+            AcpcPokerTypes::Card.from_acpc('6h'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:full_house)
+      end
+    end
+    describe 'flush' do
+      it 'works for the smallest flush' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('3c'),
+            AcpcPokerTypes::Card.from_acpc('4c'),
+            AcpcPokerTypes::Card.from_acpc('5c'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('6s'),
+            AcpcPokerTypes::Card.from_acpc('Th')
+          ]
+        ).to_poker_hand_key.must_equal(:flush)
+      end
+      it 'works for a larger flush' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Qc'),
+            AcpcPokerTypes::Card.from_acpc('Tc'),
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('3c'),
+            AcpcPokerTypes::Card.from_acpc('3s'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:flush)
+      end
+    end
+    describe 'straight' do
+      it 'works for the smallest straight' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('3h'),
+            AcpcPokerTypes::Card.from_acpc('4s'),
+            AcpcPokerTypes::Card.from_acpc('5d'),
+            AcpcPokerTypes::Card.from_acpc('Ac'),
+            AcpcPokerTypes::Card.from_acpc('8s'),
+            AcpcPokerTypes::Card.from_acpc('Th')
+          ]
+        ).to_poker_hand_key.must_equal(:straight)
+      end
+      it 'works for a larger straight' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Jc'),
+            AcpcPokerTypes::Card.from_acpc('Tc'),
+            AcpcPokerTypes::Card.from_acpc('9h'),
+            AcpcPokerTypes::Card.from_acpc('8d'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:straight)
+      end
+    end
+    describe 'three of a kind' do
+      it 'works for the smallest three_of_a_kind' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('2h'),
+            AcpcPokerTypes::Card.from_acpc('2s')
+          ]
+        ).to_poker_hand_key.must_equal(:three_of_a_kind)
+      end
+      it 'works for a larger three_of_a_kind' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Jc'),
+            AcpcPokerTypes::Card.from_acpc('Js'),
+            AcpcPokerTypes::Card.from_acpc('Jh'),
+            AcpcPokerTypes::Card.from_acpc('8d'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:three_of_a_kind)
+      end
+    end
+    describe 'two pair' do
+      it 'works for the smallest two pair' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('2h'),
+            AcpcPokerTypes::Card.from_acpc('3s'),
+            AcpcPokerTypes::Card.from_acpc('3d')
+          ]
+        ).to_poker_hand_key.must_equal(:two_pair)
+      end
+      it 'works for a larger two pair' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Jc'),
+            AcpcPokerTypes::Card.from_acpc('Js'),
+            AcpcPokerTypes::Card.from_acpc('Ah'),
+            AcpcPokerTypes::Card.from_acpc('Ad'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:two_pair)
+      end
+    end
+    describe 'one pair' do
+      it 'works for the smallest one pair' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('2h')
+          ]
+        ).to_poker_hand_key.must_equal(:one_pair)
+      end
+      it 'works for a larger one pair' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Jc'),
+            AcpcPokerTypes::Card.from_acpc('Js'),
+            AcpcPokerTypes::Card.from_acpc('Ah'),
+            AcpcPokerTypes::Card.from_acpc('8d'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:one_pair)
+      end
+    end
+    describe 'high card' do
+      it 'works for the smallest high card' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c')
+          ]
+        ).to_poker_hand_key.must_equal(:high_card)
+      end
+      it 'works for a larger high card' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Jc'),
+            AcpcPokerTypes::Card.from_acpc('3s'),
+            AcpcPokerTypes::Card.from_acpc('Ah'),
+            AcpcPokerTypes::Card.from_acpc('8d'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_key.must_equal(:high_card)
+      end
+    end
+  end
+
+  describe '#to_poker_hand_description' do
+    it 'works for royal flush' do
+      AcpcPokerTypes::PileOfCards.new(
+        [
+          AcpcPokerTypes::Card.from_acpc('Ah'),
+          AcpcPokerTypes::Card.from_acpc('Kh'),
+          AcpcPokerTypes::Card.from_acpc('Qh'),
+          AcpcPokerTypes::Card.from_acpc('Jh'),
+          AcpcPokerTypes::Card.from_acpc('Th'),
+          AcpcPokerTypes::Card.from_acpc('2s'),
+          AcpcPokerTypes::Card.from_acpc('5c')
+        ]
+      ).to_poker_hand_description.must_equal('royal flush')
+    end
+    describe 'straight flush' do
+      it 'works for the smallest straight flush' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('5h'),
+            AcpcPokerTypes::Card.from_acpc('4h'),
+            AcpcPokerTypes::Card.from_acpc('3h'),
+            AcpcPokerTypes::Card.from_acpc('2h'),
+            AcpcPokerTypes::Card.from_acpc('Ah'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal('five-high straight flush')
+      end
+      it 'works for a larger straight flush' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Th'),
+            AcpcPokerTypes::Card.from_acpc('9h'),
+            AcpcPokerTypes::Card.from_acpc('8h'),
+            AcpcPokerTypes::Card.from_acpc('7h'),
+            AcpcPokerTypes::Card.from_acpc('6h'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal('ten-high straight flush')
+      end
+    end
+    describe 'four of a kind' do
+      it 'works for the smallest four of a kind' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2h'),
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('2d'),
+            AcpcPokerTypes::Card.from_acpc('2s')
+          ]
+        ).to_poker_hand_description.must_equal("quad twos")
+      end
+      it 'works for a larger four of a kind' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Th'),
+            AcpcPokerTypes::Card.from_acpc('Tc'),
+            AcpcPokerTypes::Card.from_acpc('Td'),
+            AcpcPokerTypes::Card.from_acpc('Ts'),
+            AcpcPokerTypes::Card.from_acpc('6h'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal("quad tens with six kicker")
+      end
+    end
+    describe 'full house' do
+      it 'works for the smallest full house' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2h'),
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('2d'),
+            AcpcPokerTypes::Card.from_acpc('3s'),
+            AcpcPokerTypes::Card.from_acpc('3h'),
+            AcpcPokerTypes::Card.from_acpc('6s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal("twos full of threes")
+      end
+      it 'works for a larger full house' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Th'),
+            AcpcPokerTypes::Card.from_acpc('Tc'),
+            AcpcPokerTypes::Card.from_acpc('Td'),
+            AcpcPokerTypes::Card.from_acpc('6s'),
+            AcpcPokerTypes::Card.from_acpc('6h'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal("tens full of sixes")
+      end
+    end
+    describe 'flush' do
+      it 'works for the smallest flush' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('3c'),
+            AcpcPokerTypes::Card.from_acpc('4c'),
+            AcpcPokerTypes::Card.from_acpc('5c'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('6s'),
+            AcpcPokerTypes::Card.from_acpc('Th')
+          ]
+        ).to_poker_hand_description.must_equal("seven, five, four, three, two flush")
+      end
+      it 'works for a larger flush' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Qc'),
+            AcpcPokerTypes::Card.from_acpc('Tc'),
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('3c'),
+            AcpcPokerTypes::Card.from_acpc('3s'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal("queen, ten, five, three, two flush")
+      end
+    end
+    describe 'straight' do
+      it 'works for the smallest straight' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('3h'),
+            AcpcPokerTypes::Card.from_acpc('4s'),
+            AcpcPokerTypes::Card.from_acpc('5d'),
+            AcpcPokerTypes::Card.from_acpc('Ac'),
+            AcpcPokerTypes::Card.from_acpc('8s'),
+            AcpcPokerTypes::Card.from_acpc('Th')
+          ]
+        ).to_poker_hand_description.must_equal("five-high straight")
+      end
+      it 'works for a larger straight' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Jc'),
+            AcpcPokerTypes::Card.from_acpc('Tc'),
+            AcpcPokerTypes::Card.from_acpc('9h'),
+            AcpcPokerTypes::Card.from_acpc('8d'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal("jack-high straight")
+      end
+    end
+    describe 'three of a kind' do
+      it 'works for the smallest three_of_a_kind' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('2h'),
+            AcpcPokerTypes::Card.from_acpc('2s')
+          ]
+        ).to_poker_hand_description.must_equal("trip twos")
+      end
+      it 'works for a larger three_of_a_kind' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Jc'),
+            AcpcPokerTypes::Card.from_acpc('Js'),
+            AcpcPokerTypes::Card.from_acpc('Jh'),
+            AcpcPokerTypes::Card.from_acpc('8d'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal(
+          "trip jacks with eight and seven"
+        )
+      end
+    end
+    describe 'two pair' do
+      it 'works for the smallest two pair' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('2h'),
+            AcpcPokerTypes::Card.from_acpc('3s'),
+            AcpcPokerTypes::Card.from_acpc('3d')
+          ]
+        ).to_poker_hand_description.must_equal('threes and twos')
+      end
+      it 'works for a larger two pair' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Jc'),
+            AcpcPokerTypes::Card.from_acpc('Js'),
+            AcpcPokerTypes::Card.from_acpc('Ah'),
+            AcpcPokerTypes::Card.from_acpc('Ad'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal('aces and jacks with seven kicker')
+      end
+    end
+    describe 'one pair' do
+      it 'works for the smallest one pair' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c'),
+            AcpcPokerTypes::Card.from_acpc('2h')
+          ]
+        ).to_poker_hand_description.must_equal('pair of twos')
+      end
+      it 'works for a larger one pair' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Jc'),
+            AcpcPokerTypes::Card.from_acpc('Js'),
+            AcpcPokerTypes::Card.from_acpc('Ah'),
+            AcpcPokerTypes::Card.from_acpc('8d'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal('pair of jacks with ace, eight, and seven')
+      end
+    end
+    describe 'high card' do
+      it 'works for the smallest high card' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('2c')
+          ]
+        ).to_poker_hand_description.must_equal('two')
+      end
+      it 'works for a larger high card' do
+        AcpcPokerTypes::PileOfCards.new(
+          [
+            AcpcPokerTypes::Card.from_acpc('Jc'),
+            AcpcPokerTypes::Card.from_acpc('3s'),
+            AcpcPokerTypes::Card.from_acpc('Ah'),
+            AcpcPokerTypes::Card.from_acpc('8d'),
+            AcpcPokerTypes::Card.from_acpc('7c'),
+            AcpcPokerTypes::Card.from_acpc('2s'),
+            AcpcPokerTypes::Card.from_acpc('5c')
+          ]
+        ).to_poker_hand_description.must_equal('ace, jack, eight, seven, and five')
+      end
+    end
+  end
 
-    def for_every_card
-      AcpcPokerTypes::Rank::DOMAIN.map do |rank, rank_properties|
-        AcpcPokerTypes::Suit::DOMAIN.map do |suit, suit_properties|
-          yield AcpcPokerTypes::Card.from_components(rank, suit)
-        end
+  def for_every_card
+    AcpcPokerTypes::Rank::DOMAIN.map do |rank, rank_properties|
+      AcpcPokerTypes::Suit::DOMAIN.map do |suit, suit_properties|
+        yield AcpcPokerTypes::Card.from_components(rank, suit)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acpc_poker_types
 version: !ruby/object:Gem::Version
-  version: 7.4.4
+  version: 7.5.0
 platform: ruby
 authors:
 - Dustin Morrill
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-16 00:00:00.000000000 Z
+date: 2015-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: process_runner
@@ -66,20 +66,34 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: inflections
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 5.0.6
+        version: '5.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 5.0.6
+        version: '5.5'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -170,6 +184,7 @@ files:
 - spec/hand_player_spec.rb
 - spec/player_spec.rb
 - spec/pile_of_cards_spec.rb
+- spec/acpc_poker_types_spec.rb
 - spec/hand_spec.rb
 - spec/coverage/assets/0.7.1/magnify.png
 - spec/coverage/assets/0.7.1/application.js
@@ -265,6 +280,7 @@ test_files:
 - spec/hand_player_spec.rb
 - spec/player_spec.rb
 - spec/pile_of_cards_spec.rb
+- spec/acpc_poker_types_spec.rb
 - spec/hand_spec.rb
 - spec/coverage/assets/0.7.1/magnify.png
 - spec/coverage/assets/0.7.1/application.js