holdem 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6926800d2c8e0220fe8dca45c426cd377616245a
-  data.tar.gz: ea61981ed82d2d411d4ae02ba1b1302f8fd526cc
+SHA256:
+  metadata.gz: 92cbd539b57a476cbfb641feded5f46b1301582b9217e85b01bd6eeb9cc0756b
+  data.tar.gz: 583437e52a957684f41b1eefc199ad20c61d8d87357d423c9da47872698575f5
 SHA512:
-  metadata.gz: 6e588537a1e5971709de0a98ee550c1962fe3134f5677a06d3c9d69d0db57bacb5dec0dc25754eea27775b183356ffdcc3c8b9869d4169f47acdaac6750e1c9a
-  data.tar.gz: 011bd038663f9f731f427fb4e98747f0ff9e3fd59156b796c968a491febdcfb8dc5dbad352bfeaa14af22f046eaeeb6acb69d6815e0b43b1cc662e2e3783c336
+  metadata.gz: 811078542e6aeb58d340f8c1713551ac15b5f37ce4207f6f1d03a5569a92fa1aef6f44e80554309b96677863e90ab8ba9e143c4ccde6c7e269a79fb8333e06c8
+  data.tar.gz: 24fe1195115613d30c418e7c6c58150ef390b08d18fdfac5a6f20186199fd31e8cd6c884a9058ae5e23d5775f74e5fad62c7316c33a7616276ba67590d0fc3e2

data/README.md

@@ -20,12 +20,12 @@ Or install it yourself as:
 
     require 'holdem'
 
-    deck = Deck.new
+    deck = Holdem::Deck.new
     deck.shuffle!
 
-    hand1 = PokerHand.new(deck.deal(7))
-    hand2 = PokerHand.new(deck.deal(7))
-    hand3 = PokerHand.new("4c Kc 4h 5d 6s Kd Qs")
+    hand1 = Holdem::PokerHand.new(deck.deal(7))
+    hand2 = Holdem::PokerHand.new(deck.deal(7))
+    hand3 = Holdem::PokerHand.new("4c Kc 4h 5d 6s Kd Qs")
 
     puts hand1                     # => 5♦ K♣ T♠ J♥ 8♥ 8♠ 2♥ -> Pair of 8s
     puts hand2                     # => Q♦ 6♦ 2♦ 6♣ 5♥ 6♠ T♦ -> Three of a Kind (trip 6s)
@@ -45,16 +45,16 @@ Face cards (ten, jack, queen, king, and ace) are represented by (T, J, Q, K, A).
 
 Suits (club, diamond, spade, heart) are represented by (c, d, s, h).
     
-    puts PokerHand.new('Ac 7d 4c Td Qc Qh Ks')     # => A♣ 7♦ 4♣ T♦ Q♣ Q♥ K♠ -> Pair of Qs
+    puts Holdem::PokerHand.new('Ac 7d 4c Td Qc Qh Ks')     # => A♣ 7♦ 4♣ T♦ Q♣ Q♥ K♠ -> Pair of Qs
 
     card1, card2 = Card.new('Ad'), Card.new('Ah')     
-    puts PokerHand.new([card1, card2])             # => A♦ A♥ -> Pair of As
+    puts Holdem::PokerHand.new([card1, card2])             # => A♦ A♥ -> Pair of As
 
 There is also a Deck class to facilitate random poker hands:
     
-    deck  = Deck.new.shuffle!
+    deck  = Holdem::Deck.new.shuffle!
     cards = deck.deal(7)
-    hand  = PokerHand.new(cards)
+    hand  = Holdem::PokerHand.new(cards)
     puts hand    # => K♦ 5♣ 4♣ 8♣ J♠ 3♣ 7♦ -> K high
 
 A number of ranks can be asked about a hand:

data/holdem.gemspec

@@ -18,8 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency 'minitest', '~> 5.4.3'
-  spec.add_development_dependency 'minitest-reporters', '~> 1.0.8'
+  spec.add_development_dependency "bundler", "~> 2.1.4"
+  spec.add_development_dependency "rake", "~> 13.0.1"
+  spec.add_development_dependency 'minitest', '~> 5.14.1'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.4.2'
 end

data/lib/holdem/card.rb

@@ -1,35 +1,37 @@
-class Card
-  include Comparable
-  attr_reader :rank, :suit, :icon
+module Holdem
+  class Card
+    include Comparable
+    attr_reader :rank, :suit, :icon
 
-  RANKS       = %w(2 3 4 5 6 7 8 9 T J Q K A)
-  SUITS       = %w(c s d h)
-  ICONS       = { 'c' => '♣', 's' => '♠', 'd' => '♦', 'h' => '♥' }
-  FACE_CARDS  = { 'T' => 10, 'J' => 11, 'Q' => 12, 'K' => 13, 'A' => 14 }
+    RANKS       = %w(2 3 4 5 6 7 8 9 T J Q K A)
+    SUITS       = %w(c s d h)
+    ICONS       = { 'c' => '♣', 's' => '♠', 'd' => '♦', 'h' => '♥' }
+    FACE_CARDS  = { 'T' => 10, 'J' => 11, 'Q' => 12, 'K' => 13, 'A' => 14 }
 
-  def initialize(card)
-    @rank, @suit = card.chars if card.respond_to?(:chars)
-    @icon = ICONS[suit]
-    validate(card)
-  end
+    def initialize(card)
+      @rank, @suit = card.chars if card.respond_to?(:chars)
+      @icon = ICONS[suit]
+      validate(card)
+    end
 
-  def value
-    rank[/\d/] ? rank.to_i : FACE_CARDS[rank]
-  end
+    def value
+      rank[/\d/] ? rank.to_i : FACE_CARDS[rank]
+    end
 
-  def to_s
-    "#{rank}#{icon}"
-  end
+    def to_s
+      "#{rank}#{icon}"
+    end
 
-  def <=>(other)
-    value <=> other.value
-  end
+    def <=>(other)
+      value <=> other.value
+    end
 
-  private
+    private
 
-  def validate(card)
-    unless RANKS.include?(rank) && SUITS.include?(suit)
-      fail ArgumentError
+    def validate(card)
+      unless RANKS.include?(rank) && SUITS.include?(suit)
+        fail ArgumentError
+      end
     end
   end
-end
+end

data/lib/holdem/card_generator.rb

@@ -1,11 +1,13 @@
-class CardGenerator
-  def self.build(cards)
-    new(cards).cards
-  end
+module Holdem
+  class CardGenerator
+    def self.build(cards)
+      new(cards).cards
+    end
 
-  attr_reader :cards
-  
-  def initialize(cards)
-    @cards = cards.each.map { |c| Card.new(c) }
+    attr_reader :cards
+    
+    def initialize(cards)
+      @cards = cards.each.map { |c| Card.new(c) }
+    end
   end
 end

data/lib/holdem/deck.rb

@@ -1,23 +1,25 @@
 require 'forwardable'
 
-class Deck
-  extend Forwardable
-  def_delegators :@deck, :shuffle, :shuffle!, :pop, :size
-  attr_reader :deck
+module Holdem
+  class Deck
+    extend Forwardable
+    def_delegators :@deck, :shuffle, :shuffle!, :pop, :size
+    attr_reader :deck
 
-  def initialize
-    @deck = []
-    build_deck
-  end
+    def initialize
+      @deck = []
+      build_deck
+    end
 
-  alias_method :deal, :pop
-  alias_method :count, :size
+    alias_method :deal, :pop
+    alias_method :count, :size
 
-  private
+    private
 
-  def build_deck
-    Card::RANKS.each do |rank|
-      Card::SUITS.each { |suit| deck << Card.new(rank + suit) }
+    def build_deck
+      Card::RANKS.each do |rank|
+        Card::SUITS.each { |suit| deck << Card.new(rank + suit) }
+      end
     end
   end
 end

data/lib/holdem/poker_hand.rb

@@ -1,34 +1,36 @@
 require 'forwardable'
 
-class PokerHand
-  include Comparable
-  extend Forwardable
-
-  rank_methods = [ :rank, :score, :straight_flush?, :quads?, :four_of_a_kind?,
-                   :boat?, :full_house?, :flush?, :straight?, :three_of_a_kind?,
-                   :trips?, :two_pairs?, :two_pair?, :pair? ]
-  def_delegators :@poker_rank, *rank_methods
-
-  attr_reader :cards, :poker_rank
-
-  def initialize(cards)
-    @cards = cards.is_a?(String) ? CardGenerator.build(cards.split) : cards
-    @poker_rank = PokerRank.new(@cards)
-  end
-
-  def count
-    cards.size
-  end
-
-  def <=>(other)
-    score <=> other.score
-  end
-
-  def just_cards
-    "#{cards.map{ |card| card.to_s }.join(' ')}"
-  end
-
-  def to_s
-    "#{just_cards} -> #{rank}"
+module Holdem
+  class PokerHand
+    include Comparable
+    extend Forwardable
+
+    rank_methods = [ :rank, :score, :straight_flush?, :quads?, :four_of_a_kind?,
+                     :boat?, :full_house?, :flush?, :straight?, :three_of_a_kind?,
+                     :trips?, :two_pairs?, :two_pair?, :pair? ]
+    def_delegators :@poker_rank, *rank_methods
+
+    attr_reader :cards, :poker_rank
+
+    def initialize(cards)
+      @cards = cards.is_a?(String) ? CardGenerator.build(cards.split) : cards
+      @poker_rank = PokerRank.new(@cards)
+    end
+
+    def count
+      cards.size
+    end
+
+    def <=>(other)
+      score <=> other.score
+    end
+
+    def just_cards
+      "#{cards.map{ |card| card.to_s }.join(' ')}"
+    end
+
+    def to_s
+      "#{just_cards} -> #{rank}"
+    end
   end
 end

data/lib/holdem/poker_rank.rb

@@ -1,183 +1,188 @@
-class PokerRank
-  attr_reader :cards, :score, :rank
+module Holdem
+  class PokerRank
+    attr_reader :cards, :score, :rank
 
-  def initialize(cards)
-    @cards = cards
-    @score, @rank = build_ranking
-  end
+    def initialize(cards)
+      @cards = cards
+      @score, @rank = build_ranking
+    end
 
-  def build_ranking
-    case 
-      when straight_flush?   then build_straight_flush
-      when four_of_a_kind?   then build_four_kind
-      when full_house?       then build_full_house
-      when flush?            then build_flush
-      when straight?         then build_straight
-      when three_of_a_kind?  then build_three_kind
-      when two_pairs?        then build_two_pairs
-      when pair?             then build_pair
-      else
-        build_high_card
+    def build_ranking
+      case 
+        when straight_flush?   then build_straight_flush
+        when four_of_a_kind?   then build_four_kind
+        when full_house?       then build_full_house
+        when flush?            then build_flush
+        when straight?         then build_straight
+        when three_of_a_kind?  then build_three_kind
+        when two_pairs?        then build_two_pairs
+        when pair?             then build_pair
+        else
+          build_high_card
+      end
     end
-  end
 
-# POKER HAND RANKINGS
-# These methods determine type of poker hand. Hands are sorted by pair, then by
-# values in descending order using the #pairs method.  The hand ranking methods
-# below filter the pairs array to determine type of hand.
+  # POKER HAND RANKINGS
+  # These methods determine type of poker hand. Hands are sorted by pair, then by
+  # values in descending order using the #pairs method.  The hand ranking methods
+  # below filter the pairs array to determine type of hand.
 
-  #need to fix
-  def straight_flush?
-    straight? && flush?              
-  end
+    def straight_flush?
+      sorted_cards.each_cons(5) do |check_cards|
+        return true if five_card_straight?(check_cards.map(&:value)) && check_cards.map(&:suit).uniq.one?
+      end
+      false
+    end
 
-  def four_of_a_kind?
-    kinds?(4)
-  end
+    def four_of_a_kind?
+      kinds?(4)
+    end
 
-  def full_house?
-    three_of_a_kind? && pair?
-  end
+    def full_house?
+      three_of_a_kind? && pair?
+    end
 
-  def flush?
-    suits.any? { |_,count| count >= 5 }
-  end
+    def flush?
+      suits.any? { |_,count| count >= 5 }
+    end
 
-  def straight?
-    card_values = sorted_values
-    # check for low ace straight
-    card_values.push(1) if card_values.include?(14)
-    card_values.each_cons(5) do |vals|
-      return true if five_card_straight?(vals)
+    def straight?
+      card_values = sorted_values
+      # check for low ace straight
+      card_values.push(1) if card_values.include?(14)
+      card_values.each_cons(5) do |vals|
+        return true if five_card_straight?(vals)
+      end
+      false
     end
-    false
-  end
 
-  def five_card_straight?(list)
-    (list.first - list.last).abs == 4 && list.uniq.length == 5
-  end
+    def five_card_straight?(list)
+      (list.first - list.last).abs == 4 && list.uniq.length == 5
+    end
 
-  def three_of_a_kind?
-    kinds?(3)
-  end
+    def three_of_a_kind?
+      kinds?(3)
+    end
 
-  def two_pairs?
-    num_of_pairs = pairs.select { |count,_cards| count == 2 }.size
-    num_of_pairs > 1
-  end
+    def two_pairs?
+      num_of_pairs = pairs.select { |count,_cards| count == 2 }.size
+      num_of_pairs > 1
+    end
 
-  def pair?
-    kinds?(2)
-  end
+    def pair?
+      kinds?(2)
+    end
 
-  def kinds?(size)
-    pairs.any? { |count,_cards| count == size }
-  end
+    def kinds?(size)
+      pairs.any? { |count,_cards| count == size }
+    end
 
-  alias_method :quads?, :four_of_a_kind?
-  alias_method :trips?, :three_of_a_kind?
-  alias_method :boat?, :full_house?
-  alias_method :two_pair?, :two_pairs?
+    alias_method :quads?, :four_of_a_kind?
+    alias_method :trips?, :three_of_a_kind?
+    alias_method :boat?, :full_house?
+    alias_method :two_pair?, :two_pairs?
 
 
-# BUILD HAND RANKINGS
-# Score are first ranked by type of hand [0-9].  If equal, then compared by pairs, 
-# high cards, and/or remaining cards.  Also includes description of hand.
+  # BUILD HAND RANKINGS
+  # Score are first ranked by type of hand [0-9].  If equal, then compared by pairs, 
+  # high cards, and/or remaining cards.  Also includes description of hand.
 
-  def build_high_card
-    [ [0] + sorted_values, "#{high_card.rank} high" ]
-  end
+    def build_high_card
+      [ [0] + sorted_values, "#{high_card.rank} high" ]
+    end
 
-  def build_pair
-    [ [1] + pair_card_values, "Pair of #{pair_card.rank}s" ]
-  end
+    def build_pair
+      [ [1] + pair_card_values, "Pair of #{pair_card.rank}s" ]
+    end
 
-  def build_two_pairs
-    [ [2] + pair_card_values,
-      "Two Pairs (#{pair_card(1).rank}s and #{pair_card(2).rank}s)",
-    ]
-  end
+    def build_two_pairs
+      [ [2] + pair_card_values,
+        "Two Pairs (#{pair_card(1).rank}s and #{pair_card(2).rank}s)",
+      ]
+    end
 
-  def build_three_kind
-    [ [3] + pair_card_values, "Three of a Kind (trip #{pair_card.rank}s)" ]
-  end
+    def build_three_kind
+      [ [3] + pair_card_values, "Three of a Kind (trip #{pair_card.rank}s)" ]
+    end
 
-  def build_straight
-    [ [4, highest_straight_card], "Straight" ]
-  end
+    def build_straight
+      [ [4, highest_straight_card], "Straight" ]
+    end
 
-  def build_flush
-    [ [5, highest_flush_card], "Flush" ]
-  end
+    def build_flush
+      [ [5, highest_flush_card], "Flush" ]
+    end
 
-  def build_full_house
-    [ [6] + pair_card_values, 
-      "Full House (#{pair_card(1).rank}s over #{pair_card(2).rank}s)",    
-    ]
-  end
+    def build_full_house
+      [ [6] + pair_card_values, 
+        "Full House (#{pair_card(1).rank}s over #{pair_card(2).rank}s)",    
+      ]
+    end
 
-  def build_four_kind
-    [ [7] + pair_card_values, 
-      "Four of a kind (quad #{pair_card(1).rank}s)",
-    ]
-  end
+    def build_four_kind
+      [ [7] + pair_card_values, 
+        "Four of a kind (quad #{pair_card(1).rank}s)",
+      ]
+    end
 
-  def build_straight_flush
-    [ [8, highest_straight_card], "Straight Flush" ]
-  end
+    def build_straight_flush
+      [ [8, highest_straight_card], "Straight Flush" ]
+    end
 
-  # HELPER METHODS
-  def high_card
-    sorted_cards.first
-  end
+    # HELPER METHODS
+    def high_card
+      sorted_cards.first
+    end
 
-  def highest_straight_card
-    sorted_values.each_cons(5) do |vals|
-      return vals.first if five_card_straight?(vals)
+    def highest_straight_card
+      sorted_values.each_cons(5) do |vals|
+        return vals.first if five_card_straight?(vals)
+      end
     end
-  end
 
-  def highest_flush_card
-    cards.select { |card| card.suit == flush_suit }.max.value
-  end
+    def highest_flush_card
+      cards.select { |card| card.suit == flush_suit }.max.value
+    end
 
-  def flush_suit
-    suit, count = suits.first
-    return suit if count >= 5 
-  end
+    def flush_suit
+      suit, count = suits.first
+      return suit if count >= 5 
+    end
 
-  private
+    private
 
-  # helper method to retrieve card value/rank for each pair
-  def pair_card(num=1)
-    pairs.take(num).map { |_count, cards| cards.last }.last
-  end
+    # helper method to retrieve card value/rank for each pair
+    def pair_card(num=1)
+      pairs.take(num).map { |_count, cards| cards.last }.last
+    end
 
-  # helper method to calculate poker scores
-  def pair_card_values
-    pairs.map { |_count, cards| cards.first.value }
-  end
+    # helper method to calculate poker scores
+    def pair_card_values
+      pairs.map { |_count, cards| cards.first.value }
+    end
 
-  def sorted_cards
-    @sorted_cards ||= cards.sort_by { |card| card.value * -1 }
-  end
+    def sorted_cards
+      @sorted_cards ||= cards.sort_by { |card| card.value * -1 }
+    end
 
-  def pairs
-    @pairs ||= cards.group_by { |card| card.value }
-                    .map { |_val,cards| [cards.count, cards] }
-                    .sort_by { |count,cards| [count*-1, cards.first.value*-1] }
-  end
+    def pairs
+      @pairs ||= cards.group_by { |card| card.value }
+                      .map { |_val,cards| [cards.count, cards] }
+                      .sort_by { |count,cards| [count*-1, cards.first.value*-1] }
+    end
 
-  def suits
-    @suits ||= cards.group_by { |card| card.suit }
-                    .map { |k,v| [k, v.count] }
-                    .sort_by { |k,count| [count*-1] }
-  end
+    def suits
+      @suits ||= cards.group_by { |card| card.suit }
+                      .map { |k,v| [k, v.count] }
+                      .sort_by { |k,count| [count*-1] }
+    end
 
-  def sorted_values
-    @sorted_values ||= sorted_cards.map(&:value)
+    def sorted_values
+      @sorted_values ||= sorted_cards.map(&:value)
+    end
   end
 end
 
 
 
+

data/lib/holdem/version.rb

@@ -1,3 +1,3 @@
 module Holdem
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/lib/holdem.rb

@@ -5,5 +5,3 @@ require 'holdem/deck'
 require 'holdem/poker_hand'
 require 'holdem/poker_rank'
 
-module Holdem
-end

data/test/card_test.rb

@@ -2,10 +2,10 @@ require_relative 'test_helper'
 
 class CardTest < Minitest::Test
   def setup
-    @card1 = Card.new('Kd')
-    @card2 = Card.new('Th')
-    @card3 = Card.new('4s')
-    @card4 = Card.new('7c')
+    @card1 = Holdem::Card.new('Kd')
+    @card2 = Holdem::Card.new('Th')
+    @card3 = Holdem::Card.new('4s')
+    @card4 = Holdem::Card.new('7c')
   end
 
   def test_card_rank
@@ -21,15 +21,15 @@ class CardTest < Minitest::Test
     assert_equal 'c', @card4.suit
   end
 
-   def test_card_icons
+  def test_card_icons
     assert_equal '♦', @card1.icon
     assert_equal '♥', @card2.icon
   end
 
   def test_invalid_cards
-    assert_raises(ArgumentError) { Card.new(56) }
-    assert_raises(ArgumentError) { Card.new('9k') }
-    assert_raises(ArgumentError) { Card.new('d2') }
-    assert_raises(ArgumentError) { Card.new('a card') }
+    assert_raises(ArgumentError) { Holdem::Card.new(56) }
+    assert_raises(ArgumentError) { Holdem::Card.new('9k') }
+    assert_raises(ArgumentError) { Holdem::Card.new('d2') }
+    assert_raises(ArgumentError) { Holdem::Card.new('a card') }
   end
-end
+end

data/test/deck_test.rb

@@ -3,7 +3,7 @@ require_relative 'test_helper'
 class DeckTest < Minitest::Test
 
   def setup
-    @deck = Deck.new
+    @deck = Holdem::Deck.new
   end
 
   def test_deck_has_52_cards
@@ -11,7 +11,7 @@ class DeckTest < Minitest::Test
   end
 
   def test_deck_next_card
-    card = Deck.new.pop
+    card = Holdem::Deck.new.pop
     assert_equal card, @deck.pop
     assert_equal 51, @deck.size
   end

data/test/poker_hand_test.rb

@@ -2,22 +2,22 @@ require_relative 'test_helper'
 
 class PokerHandTest < Minitest::Test
   def setup
-    hand1      = CardGenerator.build(%w(4c 4h 5s Qs Jc 9c Tc))
-    hand2      = CardGenerator.build(%w(7c 4h 7s Qs Kc Qc Tc))
-    hand3      = CardGenerator.build(%w(Ac 2c 3h 4h 5s 6c Qd))
-    hand4      = CardGenerator.build(%w(Ac 9c 9h 9h 5s 6c Qd)) 
-    @pair       = PokerHand.new(hand1)
-    @two_pairs  = PokerHand.new(hand2)
-    @three_kind = PokerHand.new(hand4)
-    @straight   = PokerHand.new(hand3)
+    hand1      = Holdem::CardGenerator.build(%w(4c 4h 5s Qs Jc 9c Tc))
+    hand2      = Holdem::CardGenerator.build(%w(7c 4h 7s Qs Kc Qc Tc))
+    hand3      = Holdem::CardGenerator.build(%w(Ac 2c 3h 4h 5s 6c Qd))
+    hand4      = Holdem::CardGenerator.build(%w(Ac 9c 9h 9h 5s 6c Qd)) 
+    @pair       = Holdem::PokerHand.new(hand1)
+    @two_pairs  = Holdem::PokerHand.new(hand2)
+    @three_kind = Holdem::PokerHand.new(hand4)
+    @straight   = Holdem::PokerHand.new(hand3)
   end
 
   def test_poker_ranking_dependency
-    assert_equal @pair.poker_rank.class, PokerRank
+    assert_equal @pair.poker_rank.class, Holdem::PokerRank
   end
 
   def test_initialize_with_string_representation
-    assert_equal 7, PokerHand.new("Ac Ad Kd 5s 5h 4c 5c").count
+    assert_equal 7, Holdem::PokerHand.new("Ac Ad Kd 5s 5h 4c 5c").count
   end
 
   def test_rank
@@ -39,8 +39,8 @@ class PokerHandTest < Minitest::Test
   end
 
   def test_comparison_with_kicker
-    other_cards = CardGenerator.build(%w(Ac 4c 4h 9h 6c Jh Qd)) 
-    other_pair  = PokerHand.new(other_cards)
+    other_cards = Holdem::CardGenerator.build(%w(Ac 4c 4h 9h 6c Jh Qd)) 
+    other_pair  = Holdem::PokerHand.new(other_cards)
     assert_equal [1, 4, 14, 12, 11, 9, 6], other_pair.score
     assert_equal [1, 4, 12, 11, 10, 9, 5], @pair.score
     assert  other_pair > @pair
@@ -54,4 +54,4 @@ class PokerHandTest < Minitest::Test
     assert @two_pairs.two_pairs?
     assert @straight.straight?
   end
-end
+end

data/test/poker_rank_test.rb

@@ -3,90 +3,89 @@ require_relative 'test_helper'
 class PokerRankingTest < Minitest::Test
 
   def test_pair
-    cards = CardGenerator.build(%w(Kd 8s 5s Kh Kc 5c Kc))
-    hand = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(Kd 8s 5s Kh Kc 5c Kc))
+    hand = Holdem::PokerHand.new(cards)
     assert hand.pair?
-    hand = PokerRank.new(cards.first(3))
+    hand = Holdem::PokerHand.new(cards.first(3))
     refute hand.pair?
   end
 
   def test_two_pair
-    cards = CardGenerator.build(%w(7d 8s 5s 7h Kc 5c Kc))
-    hand = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(7d 8s 5s 7h Kc 5c Kc))
+    hand = Holdem::PokerHand.new(cards)
     assert hand.two_pairs?
   end
 
   def test_three_of_a_kind
-    cards = CardGenerator.build(%w(Kh Kc 5c Kc))
-    hand = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(Kh Kc 5c Kc))
+    hand = Holdem::PokerHand.new(cards)
     assert hand.three_of_a_kind?
     refute hand.pair?
   end
 
   def test_four_of_a_kind
-    cards = CardGenerator.build(%w(Ah Ac 5c 4c As Ad))
-    hand = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(Ah Ac 5c 4c As Ad))
+    hand = Holdem::PokerHand.new(cards)
     assert_equal true, hand.four_of_a_kind?
   end
 
   def test_flush?
-    cards = CardGenerator.build(%w(6c Tc 2c 4c As Ac Qh))
-    hand = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(6c Tc 2c 4c As Ac Qh))
+    hand = Holdem::PokerHand.new(cards)
     assert hand.flush?
   end
 
   def test_not_a_flush?
-    cards = CardGenerator.build(%w(6c Ts 2d 4c As Ac Qh))
-    hand = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(6c Ts 2d 4c As Ac Qh))
+    hand = Holdem::PokerHand.new(cards)
     refute hand.flush?
   end
 
   def test_for_straight?
-    cards = CardGenerator.build(%w(Td Kd Js Qd Kh Ad 9c 8c))
-    hand = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(Td Kd Js Qd Kh Ad 9c 8c))
+    hand = Holdem::PokerHand.new(cards)
     assert_equal true, hand.straight?
-    hand = PokerRank.new(cards.drop(1))
+    hand = Holdem::PokerHand.new(cards.drop(1))
     refute hand.straight?
   end
 
   def test_low_ace_straight?
-    cards = CardGenerator.build(%w(2d 3s Ad 5h 4d Td 9c 8c))
-    hand = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(2d 3s Ad 5h 4d Td 9c 8c))
+    hand = Holdem::PokerHand.new(cards)
     assert_equal true, hand.straight?
   end
 
-   def test_full_house?
-    cards = CardGenerator.build(%w(Jd 8s Jh 5h 8d Jd Tc))
-    hand = PokerRank.new(cards)
+  def test_full_house?
+    cards = Holdem::CardGenerator.build(%w(Jd 8s Jh 5h 8d Jd Tc))
+    hand = Holdem::PokerHand.new(cards)
     assert_equal true, hand.full_house?
   end
 
-   def test_straight_flush?
-    skip
-    cards1 = CardGenerator.build(%w(Jd Qd Ad Kd Td 7d Tc))
-    hand1  = PokerRank.new(cards1)
-    cards2 = CardGenerator.build(%w(2d 3h 4h 5h 6h 7d 8h))
-    hand2  = PokerRank.new(cards2)
+  def test_straight_flush?
+    cards1 = Holdem::CardGenerator.build(%w(Jd Qd Ad Kd Td 7d Tc))
+    hand1  = Holdem::PokerHand.new(cards1)
+    cards2 = Holdem::CardGenerator.build(%w(2d 3h 4h 5h 6h 7d 8h))
+    hand2  = Holdem::PokerHand.new(cards2)
     assert hand1.straight_flush?
     refute hand2.straight_flush?
   end
 
   def test_alias_method_trips?
-    cards = CardGenerator.build(%w(Jd Qd Jd Jd Td 7d Tc))
-    hand  = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(Jd Qd Jd Jd Td 7d Tc))
+    hand  = Holdem::PokerHand.new(cards)
     assert hand.trips?
   end
 
   def test_alias_method_quads?
-    cards = CardGenerator.build(%w(Jd Jd Jd Jd Td 7d Tc))
-    hand  = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(Jd Jd Jd Jd Td 7d Tc))
+    hand  = Holdem::PokerHand.new(cards)
     assert hand.quads?
   end
 
   def test_alias_method_boat?
-    cards = CardGenerator.build(%w(Jd Jd Jd Td Td 7d 6c))
-    hand  = PokerRank.new(cards)
+    cards = Holdem::CardGenerator.build(%w(Jd Jd Jd Td Td 7d 6c))
+    hand  = Holdem::PokerHand.new(cards)
     assert hand.boat?
   end
 
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: holdem
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Jamie Berczel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-09 00:00:00.000000000 Z
+date: 2020-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,56 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: 2.1.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: 2.1.4
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 13.0.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 13.0.1
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.4.3
+        version: 5.14.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.4.3
+        version: 5.14.1
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.8
+        version: 1.4.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.8
+        version: 1.4.2
 description: A ruby module for creating and comparing Texas Holdem poker hands.
 email:
 - jxberc@gmail.com
@@ -110,8 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: A ruby module for creating and comparing Texas Holdem poker hands.