poker_hands 0.0.4 → 0.0.5

data/lib/deck/hand.rb

@@ -1,17 +1,18 @@
+require 'deck/rank_selector'
 module Deck
 class Hand
   include ::Deck::RankSelector
   include Comparable
 
-  attr_reader :hand, :rank
+  attr_reader :cards, :rank
 
-  def initialize(hand)
-    @hand = hand
+  def initialize(hand_cards)
+    @cards = hand_cards
     @rank = select_rank
   end
 
   def only_values
-    @hand.map { |card| card.value}
+    @cards.map { |card| card.value}
   end
 
   private

data/lib/deck/rank_selector.rb

@@ -1,12 +1,13 @@
-module Deck::RankSelector
+module Deck
+module RankSelector
 
   def is_pair?
-    only_value = @hand.map { |card| card.value}
+    only_value = @cards.map { |card| card.value}
     only_value.detect { |card| only_value.count(card) > 1}
   end
 
   def is_two_pairs?
-    only_value = @hand.map { |card| card.value}
+    only_value = @cards.map { |card| card.value}
     first_value = only_value.detect { |card| only_value.count(card) == 2}
     if first_value
       only_value.delete(first_value)
@@ -16,23 +17,23 @@ module Deck::RankSelector
   end
 
   def is_three_of_a_kind?
-    only_value = @hand.map { |card| card.value}
+    only_value = @cards.map { |card| card.value}
     only_value.detect { |card| only_value.count(card) == 3}
   end
 
   def is_straight?
-    only_value = @hand.map { |card| card.value}
+    only_value = @cards.map { |card| card.value}
     sorted_only_value = only_value.sort
     only_value === sorted_only_value
   end
 
   def is_flush?
-    only_suits = @hand.map { |card| card.suit}
+    only_suits = @cards.map { |card| card.suit}
     only_suits.detect { |card| only_suits.count(card) == 5}
   end
 
   def is_full_house?
-    only_value = @hand.map { |card| card.value}
+    only_value = @cards.map { |card| card.value}
     first_value = only_value.detect { |card| only_value.count(card) == 3}
     if first_value
       only_value.delete(first_value)
@@ -42,17 +43,17 @@ module Deck::RankSelector
   end
 
   def is_four_of_a_kind?
-    only_value = @hand.map { |card| card.value}
+    only_value = @cards.map { |card| card.value}
     only_value.detect { |card| only_value.count(card) == 4}
   end
 
   def is_straight_flush?
-    only_suits = @hand.map { |card| card.suit}
+    only_suits = @cards.map { |card| card.suit}
     all_same_suit = only_suits.detect { |card| only_suits.count(card) == 5}
 
-    only_value = @hand.map { |card| card.value}
+    only_value = @cards.map { |card| card.value}
     sorted_only_value = only_value.sort
     all_same_suit && only_value === sorted_only_value
   end
-
+end
 end

data/lib/poker_hands.rb

@@ -8,7 +8,7 @@ require 'rank/four_of_a_kind'
 require 'rank/full_house'
 require 'rank/high_card'
 require 'rank/pair'
-require 'rank/rank'
+require 'rank/hand_rank'
 require 'rank/straight'
 require 'rank/straight_flush'
 require 'rank/three_of_a_kind'
@@ -37,7 +37,7 @@ class PokerHands
   private
 
   def same_best_rank?(rank)
-    rank.first.rank.class == rank.second.rank.class
+    rank[0].rank.class == rank[1].rank.class
   end
 
   def find_winner_if_same_rank(sorted_hands)

data/lib/rank/flush.rb

@@ -1,5 +1,6 @@
+require 'rank/hand_rank'
 module Rank
-  class Flush < Rank
+  class Flush < HandRank
     SCORE = 6
   end
 end

data/lib/rank/four_of_a_kind.rb

@@ -1,5 +1,6 @@
+require 'rank/hand_rank'
 module Rank
-  class FourOfAKind < Rank
+  class FourOfAKind < HandRank
     SCORE = 8
 
     def <=>(hand)

data/lib/rank/full_house.rb

@@ -1,5 +1,6 @@
+require 'rank/hand_rank'
 module Rank
-class FullHouse < Rank
+class FullHouse < HandRank
   SCORE = 7
 
   def <=>(hand)

data/lib/rank/{rank.rb → hand_rank.rb}

@@ -1,12 +1,12 @@
 module Rank
-class Rank
+class HandRank
   include Comparable
   def initialize(hand)
     @hand = hand
   end
 
   def only_values
-    @hand.hand.map { |card| card.value}
+    @hand.cards.map { |card| card.value}
   end
 
   def <=>(hand)

data/lib/rank/high_card.rb

@@ -1,5 +1,6 @@
+require 'rank/hand_rank'
 module Rank
-class HighCard < Rank
+class HighCard < HandRank
   SCORE = 1
 end
 end

data/lib/rank/pair.rb

@@ -1,5 +1,6 @@
+require 'rank/hand_rank'
 module Rank
-class Pair < Rank
+class Pair < HandRank
   SCORE = 2
 
   def <=>(hand)

data/lib/rank/straight.rb

@@ -1,5 +1,6 @@
+require 'rank/hand_rank'
 module Rank
-class Straight < Rank
+class Straight < HandRank
   SCORE = 5
 end
 end

data/lib/rank/straight_flush.rb

@@ -1,5 +1,6 @@
+require 'rank/hand_rank'
 module Rank
-class StraightFlush < Rank
+class StraightFlush < HandRank
   SCORE = 9
 end
 end

data/lib/rank/three_of_a_kind.rb

@@ -1,5 +1,6 @@
+require 'rank/hand_rank'
 module Rank
-class ThreeOfAKind < Rank
+class ThreeOfAKind < HandRank
   SCORE = 4
 
   def <=>(hand)

data/lib/rank/two_pairs.rb

@@ -1,5 +1,6 @@
+require 'rank/hand_rank'
 module Rank
-class TwoPairs < Rank
+class TwoPairs < HandRank
   SCORE = 3
 
   def <=>(hand)

data/{poker-hands.gemspec → poker_hands.gemspec}

@@ -9,10 +9,10 @@ Gem::Specification.new do |s|
   s.description = "Sample app to play poker"
   s.authors     = ["Cosimo Ranieri"]
   s.email       = 'co.ranieri@gmail.com'
-  s.files       = %w(README.md Rakefile poker-hands.gemspec)
+  s.files       = %w(README.md Rakefile poker_hands.gemspec)
   s.files      += Dir.glob("lib/**/*")
   s.files      += Dir.glob("spec/**/*")
-  s.version     = '0.0.4'
+  s.version     = '0.0.5'
   s.homepage    = 'https://rubygems.org/gems/poker-hands'
   s.license     = 'MIT'
 end

data/spec/{hand_spec.rb → deck/hand_spec.rb}

@@ -1,68 +1,67 @@
 require 'spec_helper'
-
-describe Hand do
+describe Deck::Hand do
 
   describe ".new" do
     context "the hand is a high card" do
-      let(:hand) { Hand.new(high_card)}
+      let(:hand) { Deck::Hand.new(high_card)}
       it "creates a high card hand" do
-        expect(hand.rank.class).to eq HighCard
+        expect(hand.rank.class).to eq Rank::HighCard
       end
     end
 
     context "the hand is a pair" do
-      let(:hand) { Hand.new(pair)}
+      let(:hand) { Deck::Hand.new(pair)}
       it "creates a high card hand" do
-        expect(hand.rank.class).to eq Pair
+        expect(hand.rank.class).to eq Rank::Pair
       end
     end
 
     context "the hand is two pairs" do
-      let(:hand) { Hand.new(two_pairs)}
+      let(:hand) { Deck::Hand.new(two_pairs)}
       it "creates a high card hand" do
-        expect(hand.rank.class).to eq TwoPairs
+        expect(hand.rank.class).to eq Rank::TwoPairs
       end
     end
 
     context "the hand is three of a kind" do
-      let(:hand) { Hand.new(three_of_a_kind)}
+      let(:hand) { Deck::Hand.new(three_of_a_kind)}
       it "creates a high card hand" do
-        expect(hand.rank.class).to eq ThreeOfAKind
+        expect(hand.rank.class).to eq Rank::ThreeOfAKind
       end
     end
 
     context "the hand is straight" do
-      let(:hand) { Hand.new(straight)}
+      let(:hand) { Deck::Hand.new(straight)}
       it "creates a high card hand" do
-        expect(hand.rank.class).to eq Straight
+        expect(hand.rank.class).to eq Rank::Straight
       end
     end
 
     context "the hand is a flush" do
-      let(:hand) { Hand.new(flush)}
+      let(:hand) { Deck::Hand.new(flush)}
       it "creates a flush hand" do
-        expect(hand.rank.class).to eq Flush
+        expect(hand.rank.class).to eq Rank::Flush
       end
     end
 
     context "the hand is a full house" do
-      let(:hand) { Hand.new(full_house)}
+      let(:hand) { Deck::Hand.new(full_house)}
       it "creates a flush full house" do
-        expect(hand.rank.class).to eq FullHouse
+        expect(hand.rank.class).to eq Rank::FullHouse
       end
     end
 
     context "the hand is a four of a kind" do
-      let(:hand) { Hand.new(four_of_a_kind)}
+      let(:hand) { Deck::Hand.new(four_of_a_kind)}
       it "creates a four of a kind full house" do
-        expect(hand.rank.class).to eq FourOfAKind
+        expect(hand.rank.class).to eq Rank::FourOfAKind
       end
     end
 
     context "the hand is a straight flush" do
-      let(:hand) { Hand.new(straight_flush)}
+      let(:hand) { Deck::Hand.new(straight_flush)}
       it "creates a four of a straight flush" do
-        expect(hand.rank.class).to eq StraightFlush
+        expect(hand.rank.class).to eq Rank::StraightFlush
       end
     end
 

data/spec/{table_spec.rb → poker_hands_spec.rb}

@@ -1,187 +1,186 @@
 require 'spec_helper'
 
-describe Table do
+describe PokerHands do
   describe "#winner" do
-    let(:table) { Table.new}
-    context "the table contains a straight flush as best hand" do
+    let(:poker) { PokerHands.new}
+    context "the game contains a straight flush as best hand" do
       context "there is only one straight flush hand" do
         before do
-          table.hands = hand_straight_flush
+          poker.hands = hand_straight_flush
         end
         it "return an array where the last element is a straight flush " do
-          expect(table.winner.rank.class).to eq StraightFlush
+          expect(poker.winner.rank.class).to eq Rank::StraightFlush
         end
       end
 
       context "there are two straight flush hands" do
         before do
-          table.hands = hand_two_straight_flush
+          poker.hands = hand_two_straight_flush
         end
         it "return an array where the last element is the highest straight flush " do
-          only_val = Hand.new(table.winner.hand).only_values
+          only_val = Deck::Hand.new(poker.winner.hand).only_values
           expect(only_val.max).to eq "8"
         end
       end
 
     end
 
-    context "the table contains a four of a kind as best hand" do
+    context "the game contains a four of a kind as best hand" do
       context "there is one four of a kind hand" do
         before do
-          table.hands = hand_four_of_a_kind
+          poker.hands = hand_four_of_a_kind
         end
         it "return an array where the last element is a four of a kind " do
-          expect(table.winner.rank.class).to eq FourOfAKind
+          expect(poker.winner.rank.class).to eq Rank::FourOfAKind
         end
       end
 
       context "there are two four of a kind hands" do
         before do
-          table.hands = hand_same_four_of_a_kind
+          poker.hands = hand_same_four_of_a_kind
         end
         it "return an array where the last element is a four of a kind " do
-          only_val = Hand.new(table.winner.hand).only_values
+          only_val = Deck::Hand.new(poker.winner.hand).only_values
           expect(only_val.max).to eq "5"
         end
       end
     end
 
-    context "the table contains a full house as best hand" do
+    context "the game contains a full house as best hand" do
       context "there is only one full house" do
         before do
-          table.hands = hand_full_house
+          poker.hands = hand_full_house
         end
         it "return an array where the last element is a full house hand " do
-          expect(table.winner.rank.class).to eq FullHouse
+          expect(poker.winner.rank.class).to eq Rank::FullHouse
         end
       end
 
       context "there are two full house hands" do
         before do
-          table.hands = hand_same_full_house
+          poker.hands = hand_same_full_house
         end
         it "return an array where the last element is highest full house " do
-          only_val = Hand.new(table.winner.hand).only_values
-          p only_val
+          only_val = Deck::Hand.new(poker.winner.hand).only_values
           expect(only_val.max).to eq "5"
         end
       end
 
     end
 
-    context "the table contains a flush as best hand" do
+    context "the game contains a flush as best hand" do
       context "there is only one flush hand" do
         before do
-          table.hands = hand_flush
+          poker.hands = hand_flush
         end
         it "return an array where the last element is a flush " do
-          expect(table.winner.rank.class).to eq Flush
+          expect(poker.winner.rank.class).to eq Rank::Flush
         end
       end
 
       context "there is two one flush hand" do
         before do
-          table.hands = hand_two_flush
+          poker.hands = hand_two_flush
         end
         it "return an array where the last element is the highest flush " do
-          only_val = Hand.new(table.winner.hand).only_values
+          only_val = Deck::Hand.new(poker.winner.hand).only_values
           expect(only_val.max).to eq "8"
         end
       end
 
     end
 
-    context "the table contains a straight as best hand" do
+    context "the game contains a straight as best hand" do
       context "there is only one straight hand" do
         before do
-          table.hands = hand_straight
+          poker.hands = hand_straight
         end
         it "return an array where the last element is a straight " do
-          expect(table.winner.rank.class).to eq Straight
+          expect(poker.winner.rank.class).to eq Rank::Straight
         end
       end
 
       context "there are two straight hands" do
         before do
-          table.hands = hand_same_straight
+          poker.hands = hand_same_straight
         end
         it "return an array where the last element the highest straight" do
-          only_val = Hand.new(table.winner.hand).only_values
+          only_val = Deck::Hand.new(poker.winner.hand).only_values
           expect(only_val.last).to eq "8"
         end
       end
 
     end
 
-    context "the table contains a three of a kind as best hand" do
+    context "the game contains a three of a kind as best hand" do
       context "there is only one three of a kind hand" do
         before do
-          table.hands = hand_three_of_a_kind
+          poker.hands = hand_three_of_a_kind
         end
         it "return an array where the last element is a three of a kind " do
-          expect(table.winner.rank.class).to eq ThreeOfAKind
+          expect(poker.winner.rank.class).to eq Rank::ThreeOfAKind
         end
       end
 
       context "there are two three of a kind hands" do
         before do
-          table.hands = hand_some_three_of_a_kind
+          poker.hands = hand_some_three_of_a_kind
         end
         it "return an array where the last element is a three of a kind " do
-          only_val = Hand.new(table.winner.hand).only_values
+          only_val = Deck::Hand.new(poker.winner.hand).only_values
           expect(only_val.last).to eq "8"
         end
       end
     end
 
-    context "the table contains a two pairs as best hand" do
+    context "the game contains a two pairs as best hand" do
       before do
-        table.hands = hand_two_pairs
+        poker.hands = hand_two_pairs
       end
       it "return an array where the last element is a two pairs  " do
-        expect(table.winner.rank.class).to eq TwoPairs
+        expect(poker.winner.rank.class).to eq Rank::TwoPairs
       end
 
-      context "the tables contains thw hands with same two pairs" do
+      context "the game contains thw hands with same two pairs" do
         before do
-          table.hands = hand_same_two_pairs
+          poker.hands = hand_same_two_pairs
         end
         it "return an array where the last element is the two pairs with the highest remaining card" do
-          only_val = Hand.new(table.winner.hand).only_values
+          only_val = Deck::Hand.new(poker.winner.hand).only_values
           expect(only_val.last).to eq "8"
         end
       end
     end
 
-    context "the table contains a pair as best hand" do
+    context "the game contains a pair as best hand" do
       context "the tables contains a unique pair hand" do
         before do
-          table.hands = hand_pair
+          poker.hands = hand_pair
         end
         it "return an array where the last element is a pair  " do
-          expect(table.winner.rank.class).to eq Pair
+          expect(poker.winner.rank.class).to eq Rank::Pair
         end
       end
 
-      context "the tables contains the hands with same pairs" do
+      context "the game contains the hands with same pairs" do
         before do
-          table.hands = hand_same_pair
+          poker.hands = hand_same_pair
         end
         it "return an array where the last element is the pair with the highest remaining card" do
-          only_val = Hand.new(table.winner.hand).only_values
+          only_val = Deck::Hand.new(poker.winner.hand).only_values
           expect(only_val.last).to eq "8"
         end
       end
 
     end
 
-    context "the table contains a high card as best hand" do
+    context "the game contains a high card as best hand" do
       context "the highest cards have the same value" do
         before do
-          table.hands = hand_high_card_same_highest
+          poker.hands = hand_high_card_same_highest
         end
         it "return an array where the last element is a high card with the next highest value" do
-          only_val = Hand.new(table.winner.hand).only_values
+          only_val = Deck::Hand.new(poker.winner.hand).only_values
           only_val.sort!
           expect(only_val[only_val.length - 2]).to eq "7"
         end
@@ -189,10 +188,10 @@ describe Table do
 
       context "the highest card is unique" do
         before do
-          table.hands = hand_high_card
+          poker.hands = hand_high_card
         end
         it "return an array where the last element is a high card  " do
-          expect(table.winner.rank.class).to eq HighCard
+          expect(poker.winner.rank.class).to eq Rank::HighCard
         end
       end