texas-holdem 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eda1eff093ca7de35fa918d0c108fe9ce5b9eed1
+  data.tar.gz: 35a40aa0f3020019dab30d9b7e44a4d15c4f40f3
+SHA512:
+  metadata.gz: 1bbc1ea749be628c35f2209fb06c546fd3623b417a54014548b8db44d0b961664d6a1b1cce41fdd9daa16b8d564e8902f371f404693a5603089f6c323806c4a7
+  data.tar.gz: b4486b6717c5582cb6237e90380bb26f2a9acf9477ad684f1899889b7b5978c99b9b358fd26900c0a30fc4f7e98451765b660a6d8b5abb24a9cbb7fd97cd130f

data/.gitignore

@@ -0,0 +1,36 @@
+.idea
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--require spec_helper
+--require combinations/shared_combination_examples
+--format documentation

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1,16 @@
+# texas-holdem
+
+Gem that provides basic classes for Texas Holdem Poker game
+
+##Installation
+
+`gem install texas-holdem`
+
+##Usage
+
+To play a game just use gem's binary: `texas-holdem`
+
+TODO
+
+Add more combinations
+Add betting rounds

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec

data/bin/texas-holdem

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'texas-holdem'
+
+loop do
+  TexasHoldem::Game.new(2, TexasHoldem::Deck.new)
+  puts 'Want to play another game? y/n'
+  break if (gets.chomp).downcase == 'n'
+end

data/lib/texas-holdem.rb

@@ -0,0 +1,13 @@
+require 'texas-holdem/card'
+require 'texas-holdem/deck'
+require 'texas-holdem/game'
+require 'texas-holdem/player_hand'
+require 'texas-holdem/combinations/combination'
+require 'texas-holdem/combinations/highest_card'
+require 'texas-holdem/combinations/pair'
+require 'texas-holdem/combinations/two_pairs'
+require 'texas-holdem/combinations/three_of_a_kind'
+require 'texas-holdem/combinations/straight'
+require 'texas-holdem/combinations/flush'
+require 'texas-holdem/combinations/ranks'
+

data/lib/texas-holdem/card.rb

@@ -0,0 +1,58 @@
+module TexasHoldem
+  class Card
+    include Comparable
+    NUM_RANKS = 2..10
+    FACE_CARD_RANKS = { J: 11, Q: 12, K: 13, A: 14 }
+    SUITS = {c: '♣', s: '♠', h: '♥', d: '♦'}
+    ACE_HIGH = FACE_CARD_RANKS[:A]
+    ACE_LOW = NUM_RANKS.min - 1
+
+    attr_reader :suit, :rank
+
+    def self.build_all
+      all = []
+      SUITS.each do |suit, icon|
+        NUM_RANKS.to_a.tap {|num_ranks| num_ranks.concat(FACE_CARD_RANKS.keys) }.each do |rank|
+          all << new(rank.to_s + suit.to_s)
+        end
+      end
+      all
+    end
+
+    def initialize(card_as_string)
+      @suit = parse_suit(card_as_string)
+      @rank = parse_rank(card_as_string)
+    end
+
+    def is_face_card?
+      FACE_CARD_RANKS.has_key? rank.to_sym
+    end
+
+    def to_i
+      is_face_card? ? FACE_CARD_RANKS[rank.to_sym] : rank.to_i
+    end
+
+    def to_s
+      rank + SUITS[suit.to_sym]
+    end
+
+    def <=>(other_card)
+      to_i <=> other_card.to_i
+    end
+
+    private
+
+    def parse_suit(card_as_string)
+      raw_suit = card_as_string[-1]
+      return raw_suit if SUITS[raw_suit.to_sym]
+      raise ArgumentError, "Incorrect suit #{raw_suit}. Use only #{SUITS.keys}"
+    end
+
+    def parse_rank(card_as_string)
+      raw_rank = card_as_string[0..-2]
+      return raw_rank if NUM_RANKS.include?(raw_rank.to_i)
+      return raw_rank if FACE_CARD_RANKS.include?(raw_rank.to_sym)
+      raise ArgumentError.new "Incorrect rank #{raw_rank}. Use only #{NUM_RANKS} or #{FACE_CARD_RANKS.keys}"
+    end
+  end
+end

data/lib/texas-holdem/combinations/combination.rb

@@ -0,0 +1,86 @@
+module TexasHoldem
+  module Combinations
+
+    class Combination
+      include Comparable
+      MAX_COMBINATION_LENGTH = 5
+      attr_reader :cards, :cards_by_rank, :cards_by_suit, :combination_cards, :kicker_cards
+
+      def initialize(cards)
+        @cards = cards
+        @cards_by_rank = get_cards_by_rank
+        @cards_by_suit = get_cards_by_suit
+        @combination_cards = get_combination_cards(cards)
+        @kicker_cards = get_kicker_cards
+      end
+
+      def has_combination?
+        combination_cards.length > 0
+      end
+
+      def <=>(other)
+        compared_by_rank = RANKS[self.class] <=> RANKS[other.class]
+        return compared_by_rank unless compared_by_rank == 0
+        compared_by_same_rank = compare_same_rank(other)
+        return compared_by_same_rank unless compared_by_same_rank == 0
+        compare_kickers(other)
+      end
+
+      def to_s
+        "#{combination_cards.map(&:to_s)}, kickers: #{kicker_cards.map(&:to_s)}"
+      end
+
+      private
+
+      def get_cards_by_rank
+        cards_by_rank = {}
+        cards.each do |card|
+          cards_by_rank[card.to_i] ||= []
+          cards_by_rank[card.to_i] << card
+        end
+        cards_by_rank
+      end
+
+      def get_cards_by_suit
+        cards_by_suit = {}
+        cards.each do |card|
+          cards_by_suit[card.suit] ||= []
+          cards_by_suit[card.suit] << card
+        end
+        cards_by_suit
+      end
+
+      def get_kicker_cards
+        cards.reject do |card|
+          combination_cards.include?(card)
+        end.sort{ |c1, c2| c2 <=> c1 }.take(MAX_COMBINATION_LENGTH - combination_cards.length)
+      end
+
+      #Template method
+      #every ancestor of Combination class is supposed to implement this method
+      #return -1,0 or 1 as a result of comparing two combinations of same class
+      def compare_same_rank(other)
+        raise NotImplementedError 'Provide an implementation of #compare_same_rank method in ancestors'
+      end
+
+      #Template method
+      #every ancestor of Combination class is supposed to implement this method
+      #returns an array containing all cards needed to build a combination
+      #if there is no way to build a combination return an empty array
+      def get_combination_cards(cards)
+        raise NotImplementedError 'Provide an implementation of #get_combination_cards method in ancestors'
+      end
+
+      #compares kickers of two combinations of same rank
+      #assuming kicker cards are stored in sorted array
+      def compare_kickers(other)
+        kicker_cards.each_with_index do |kicker, i|
+          other_kicker = other.kicker_cards[i]
+          compared_by_kicker = kicker <=> other_kicker
+          return compared_by_kicker unless compared_by_kicker == 0
+        end
+        0
+      end
+    end
+  end
+end

data/lib/texas-holdem/combinations/flush.rb

@@ -0,0 +1,23 @@
+module TexasHoldem
+  module Combinations
+    class Flush < Combination
+
+      def get_combination_cards(cards)
+        same_suit = cards_by_suit.find do |suit, cards_of_same_suit|
+          cards_of_same_suit.length >= 5
+        end
+        same_suit ? same_suit[1].sort.last(5) : []
+      end
+
+      def compare_same_rank(other)
+        combination_cards.each_with_index do |highest_card, i|
+          other_highest_card = other.combination_cards[i]
+          compared_by_high = highest_card <=> other_highest_card
+          return compared_by_high unless compared_by_high == 0
+        end
+        0
+      end
+
+    end
+  end
+end

data/lib/texas-holdem/combinations/highest_card.rb

@@ -0,0 +1,13 @@
+module TexasHoldem
+  module Combinations
+    class HighestCard < Combination
+      def get_combination_cards(cards)
+        cards.empty? ? [] : [cards.max]
+      end
+
+      def compare_same_rank(other)
+        combination_cards[0] <=> other.combination_cards[0]
+      end
+    end
+  end
+end

data/lib/texas-holdem/combinations/pair.rb

@@ -0,0 +1,18 @@
+module TexasHoldem
+  module Combinations
+    class Pair < Combination
+
+      def get_combination_cards(cards)
+        cards_by_rank.each do |rank, cards_of_same_rank|
+          return cards_of_same_rank if cards_of_same_rank.length == 2
+        end
+        []
+      end
+
+      def compare_same_rank(other)
+        combination_cards[0] <=> other.combination_cards[0]
+      end
+
+    end
+  end
+end

data/lib/texas-holdem/combinations/ranks.rb

@@ -0,0 +1,13 @@
+module TexasHoldem
+  module Combinations
+    #Order matters. Highest combinations should go first
+    RANKS = {
+        Flush => 6,
+        Straight => 5,
+        ThreeOfAKind => 4,
+        TwoPairs => 3,
+        Pair => 2,
+        HighestCard => 1
+    }
+  end
+end

data/lib/texas-holdem/combinations/straight.rb

@@ -0,0 +1,39 @@
+module TexasHoldem
+  module Combinations
+    class Straight < Combination
+
+      def get_combination_cards(cards)
+        ranks = add_ace_low(cards_by_rank.keys).sort
+        return [] if ranks.length < 5
+        straight = get_all_sequences(ranks).find {|seq| seq.length >= 5}
+        return [] unless straight
+        straight.last(5).map do |rank|
+          rank = Card::ACE_HIGH if rank == Card::ACE_LOW
+          cards_by_rank[rank][0]
+        end
+      end
+
+      def compare_same_rank(other)
+        combination_cards.max <=> other.combination_cards.max
+      end
+
+      def add_ace_low(ranks)
+        ranks << Card::ACE_LOW if ranks.index(Card::ACE_HIGH)
+        ranks
+      end
+
+      def get_all_sequences(ranks)
+        sequences, current_sequence = [], []
+        ranks.each do |rank|
+          if current_sequence.empty? || rank - current_sequence.last == 1
+            current_sequence << rank
+          else
+            sequences << current_sequence
+            current_sequence = [rank]
+          end
+        end
+        sequences << current_sequence
+      end
+    end
+  end
+end

data/lib/texas-holdem/combinations/three_of_a_kind.rb

@@ -0,0 +1,18 @@
+module TexasHoldem
+  module Combinations
+    class ThreeOfAKind < Combination
+
+      def get_combination_cards(cards)
+        cards_by_rank.each do |rank, cards_of_same_rank|
+          return cards_of_same_rank if cards_of_same_rank.length == 3
+        end
+        []
+      end
+
+      def compare_same_rank(other)
+        combination_cards[0] <=> other.combination_cards[0]
+      end
+
+    end
+  end
+end

data/lib/texas-holdem/combinations/two_pairs.rb

@@ -0,0 +1,25 @@
+module TexasHoldem
+  module Combinations
+    class TwoPairs < Combination
+
+      def get_combination_cards(cards)
+        pairs = []
+        cards_by_rank.each do |rank, cards_of_same_rank|
+          pairs << cards_of_same_rank if cards_of_same_rank.length == 2
+        end
+        if pairs.length == 2
+          pairs.flatten
+        elsif pairs.length > 2
+          pairs.sort_by { |pair| pair[0] }.last(2).flatten
+        else
+          []
+        end
+      end
+
+      def compare_same_rank(other)
+        combination_cards.max <=> other.combination_cards.max
+      end
+
+    end
+  end
+end

data/lib/texas-holdem/deck.rb

@@ -0,0 +1,14 @@
+module TexasHoldem
+  class Deck
+    attr_reader :cards
+
+    def initialize
+      @cards = Card.build_all
+      @cards.shuffle!
+    end
+
+    def deal(n)
+      cards.pop n
+    end
+  end
+end

data/lib/texas-holdem/game.rb

@@ -0,0 +1,22 @@
+module TexasHoldem
+  class Game
+
+    attr_reader :players, :common_cards
+
+    def initialize(players_count, deck)
+      @players = []
+      @common_cards = deck.deal(5)
+      players_count.times do |i|
+        player_cards = deck.deal(2)
+        puts "Player #{i} gets #{player_cards.map(&:to_s)}"
+        players << PlayerHand.new(player_cards.concat(@common_cards))
+      end
+      puts "Cards on table: #{@common_cards.map(&:to_s)}"
+      puts "The winner is player #{@players.index(winner)} with combination #{winner.best_combination}"
+    end
+
+    def winner
+      players.max
+    end
+  end
+end

data/lib/texas-holdem/player_hand.rb

@@ -0,0 +1,28 @@
+module TexasHoldem
+  class PlayerHand
+    include Comparable
+    attr_reader :best_combination, :cards
+
+    def initialize(cards)
+      @cards = cards
+      @best_combination = get_best_combination
+    end
+
+    def add_cards(cards)
+      @cards.push(*cards)
+      @best_combination = get_best_combination
+    end
+
+    def <=>(other)
+      best_combination <=> other.best_combination
+    end
+
+    private
+
+    def get_best_combination
+      Combinations::RANKS.keys.map do |combination_class|
+        combination_class.new(cards)
+      end.find(&:has_combination?)
+    end
+  end
+end

data/spec/card_spec.rb

@@ -0,0 +1,71 @@
+require 'rspec'
+
+describe TexasHoldem::Card do
+  
+  it 'builds a set 52 cards' do
+    expect(TexasHoldem::Card.build_all.length).to eq(52)
+  end
+
+  it 'includes Comparable' do
+    expect(TexasHoldem::Card.ancestors).to include(Comparable)
+  end
+
+  describe '#initialize' do
+    context 'when arguments are valid' do
+      before :each do
+        @card1 = TexasHoldem::Card.new('10c')
+        @card2 = TexasHoldem::Card.new('2h')
+        @card3 = TexasHoldem::Card.new('Jd')
+      end
+
+      it 'parses suit' do
+        expect(@card1.suit).to eq('c')
+        expect(@card2.suit).to eq('h')
+        expect(@card3.suit).to eq('d')
+      end
+
+      it 'parses rank' do
+        expect(@card1.rank).to eq('10')
+        expect(@card2.rank).to eq('2')
+        expect(@card3.rank).to eq('J')
+      end
+    end
+
+    context 'when arguments are invalid' do
+      it 'returns an error if suit is invalid' do
+        expect { TexasHoldem::Card.new('Qk') }.to raise_error ArgumentError
+      end
+
+      it 'returns an error if rank is invalid' do
+        expect { TexasHoldem::Card.new('Ih') }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe '#is_face_card?' do
+    it 'returns true' do
+      expect(TexasHoldem::Card.new('As').is_face_card?).to eq(true)
+    end
+
+    it 'returns false' do
+      expect(TexasHoldem::Card.new('5d').is_face_card?).to eq(false)
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns string representation of card' do
+      expect(TexasHoldem::Card.new('Qs').to_s).to eq('Q♠')
+      expect(TexasHoldem::Card.new('Ad').to_s).to eq('A♦')
+      expect(TexasHoldem::Card.new('10c').to_s).to eq('10♣')
+      expect(TexasHoldem::Card.new('9h').to_s).to eq('9♥')
+    end
+  end
+
+  describe '#<=>' do
+    it 'compares two cards' do
+      expect(TexasHoldem::Card.new('Qs')).to eq TexasHoldem::Card.new('Qc')
+      expect(TexasHoldem::Card.new('Qs')).to be > TexasHoldem::Card.new('2d')
+      expect(TexasHoldem::Card.new('Qs')).to be < TexasHoldem::Card.new('Kh')
+    end
+  end
+end

data/spec/combinations/combination_spec.rb

@@ -0,0 +1,23 @@
+require 'rspec'
+
+describe TexasHoldem::Combinations::Combination do
+
+  describe '#<=>' do
+
+    let(:highest1) { TexasHoldem::Combinations::HighestCard.new([Card.new('As'), Card.new('Jh'), Card.new('3c')]) }
+    let(:highest2) { TexasHoldem::Combinations::HighestCard.new([Card.new('Ah'), Card.new('2d'), Card.new('Js')]) }
+    let(:highest3) { TexasHoldem::Combinations::HighestCard.new([Card.new('3d'), Card.new('Js'), Card.new('Ac')]) }
+    let(:pair){ TexasHoldem::Combinations::Pair.new([Card.new('As'), Card.new('Ac')]) }
+
+    it 'compares combinations by rank' do
+      #todo add more compares
+      expect(pair).to be > highest1
+    end
+
+    it 'compares combinations by kickers' do
+      expect(highest1).to be > highest2
+      expect(highest1).to eq(highest3)
+    end
+  end
+
+end

data/spec/combinations/flush_spec.rb

@@ -0,0 +1,46 @@
+require 'rspec'
+
+describe TexasHoldem::Combinations::Flush do
+
+  include_examples 'initialising with empty array'
+
+  context 'when combination is present' do
+    include_examples 'setting combination info' do
+      let(:cards) {[ Card.new('Jh'), Card.new('Ah'), Card.new('Qh'), Card.new('3c'),
+                     Card.new('4h'),  Card.new('Js'), Card.new('6h') ]}
+      let(:kicker_cards) {[]}
+      let(:combination_cards) {['4♥', '6♥', 'J♥', 'Q♥', 'A♥']}
+    end
+  end
+
+  context 'when there is no flush' do
+    include_examples 'setting combination info' do
+      let(:cards) {[Card.new('Jh'), Card.new('Ah'), Card.new('6h'), Card.new('Qh'), Card.new('Qd')]}
+      let(:kicker_cards) {['A♥', 'Q♦', 'Q♥', 'J♥', '6♥']}
+      let(:combination_cards) {[]}
+    end
+  end
+
+  context 'when there is more than 5 cards in flush' do
+    include_examples 'setting combination info' do
+      let(:cards) {[ Card.new('Jh'), Card.new('Ah'), Card.new('Qh'), Card.new('10h'),
+                     Card.new('4h'),  Card.new('Js'), Card.new('6h') ]}
+      let(:kicker_cards) {[]}
+      let(:combination_cards) {['6♥', '10♥', 'J♥', 'Q♥', 'A♥']}
+    end
+  end
+
+  include_examples '#has_combination?' do
+    let(:cards_with_combination) {[ Card.new('Ah'), Card.new('Qh'), Card.new('10h'), Card.new('9h'), Card.new('2h') ]}
+    let(:cards_without_combination) {[Card.new('Jh'), Card.new('Ad'), Card.new('6s')]}
+  end
+
+
+  include_examples 'comparing' do
+    let(:strongest_combination) { [ Card.new('Kh'), Card.new('Qh'), Card.new('Jh'), Card.new('4h'), Card.new('5h') ] }
+    let(:middle_combination1)  { [ Card.new('Kh'), Card.new('Qh'), Card.new('10h'), Card.new('9h'), Card.new('2h') ] }
+    let(:middle_combination2) { [ Card.new('2d'), Card.new('9d'), Card.new('10d'), Card.new('Qd'), Card.new('Kd') ] }
+    let(:weakest_combination) { [ Card.new('Kh'), Card.new('Qh'), Card.new('9h'), Card.new('5h'), Card.new('2h') ] }
+  end
+
+end

data/spec/combinations/highest_card_spec.rb

@@ -0,0 +1,27 @@
+require 'rspec'
+
+describe TexasHoldem::Combinations::HighestCard do
+
+  include_examples 'initialising with empty array'
+
+  context 'when combination is present' do
+    include_examples 'setting combination info' do
+      let(:cards) {[ Card.new('Jh'), Card.new('Ad'), Card.new('Qc') ]}
+      let(:combination_cards) {['A♦']}
+      let(:kicker_cards) {['Q♣','J♥']}
+    end
+  end
+
+  include_examples '#has_combination?' do
+    let(:cards_with_combination) {[ Card.new('Ad'), Card.new('As'), Card.new('6h') ]}
+    let(:cards_without_combination) {[]}
+  end
+
+  include_examples 'comparing' do
+    let(:strongest_combination) { [Card.new('As'), Card.new('Qc')] }
+    let(:middle_combination1)  { [Card.new('2s'), Card.new('10d')] }
+    let(:middle_combination2) { [Card.new('2h'), Card.new('10h')] }
+    let(:weakest_combination) { [Card.new('2s'), Card.new('3c')] }
+  end
+
+end

data/spec/combinations/pair_spec.rb

@@ -0,0 +1,36 @@
+require 'rspec'
+
+describe TexasHoldem::Combinations::Pair do
+
+  include_examples 'initialising with empty array'
+
+  context 'when combination is present' do
+    include_examples 'setting combination info' do
+      let(:cards) {[ Card.new('Jh'), Card.new('Ad'), Card.new('Qs'), Card.new('3c'),
+                     Card.new('4d'),  Card.new('Js'), Card.new('6h') ]}
+      let(:kicker_cards) {['A♦', 'Q♠', '6♥']}
+      let(:combination_cards) {['J♥', 'J♠']}
+    end
+  end
+
+  context 'when there are no pairs' do
+    include_examples 'setting combination info' do
+      let(:cards) {[Card.new('Jh'), Card.new('Ad'), Card.new('6s')]}
+      let(:kicker_cards) {['A♦', 'J♥', '6♠']}
+      let(:combination_cards) {[]}
+    end
+  end
+
+  include_examples '#has_combination?' do
+    let(:cards_with_combination) {[ Card.new('Ad'), Card.new('As'), Card.new('6h') ]}
+    let(:cards_without_combination) {[Card.new('Jh'), Card.new('Ad'), Card.new('6s')]}
+  end
+
+  include_examples 'comparing' do
+    let(:strongest_combination) { [Card.new('As'), Card.new('Ac')] }
+    let(:middle_combination1)  { [Card.new('2s'), Card.new('2c'), Card.new('10d')] }
+    let(:middle_combination2) { [Card.new('2h'), Card.new('2d'), Card.new('10h')] }
+    let(:weakest_combination) { [Card.new('2s'), Card.new('2c'), Card.new('3c')] }
+  end
+
+end

data/spec/combinations/shared_combination_examples.rb

@@ -0,0 +1,47 @@
+require 'rspec'
+
+RSpec.shared_examples 'setting combination info' do
+  describe 'setting combination an kicker cards' do
+    it 'sets combination cards' do
+      comb_cards = described_class.new(cards).combination_cards.map(&:to_s)
+      expect(comb_cards). to eq(combination_cards)
+    end
+
+    it 'sets kicker cards' do
+      kick_cards = described_class.new(cards).kicker_cards.map(&:to_s)
+      expect(kick_cards). to eq(kicker_cards)
+    end
+  end
+end
+
+RSpec.shared_examples 'initialising with empty array' do
+  describe 'initialising with empty array of cards' do
+    it 'sets combination cards to an empty array' do
+      expect(described_class.new([]).combination_cards).to be_empty
+    end
+  end
+
+end
+
+RSpec.shared_examples '#has_combination?' do
+  describe '#has_combination?' do
+    it 'returns true when combination is present' do
+      expect(described_class.new(cards_with_combination)).to have_combination
+    end
+
+    it 'returns false when there is no combination' do
+      expect(described_class.new(cards_without_combination)).to_not have_combination
+    end
+  end
+end
+
+RSpec.shared_examples 'comparing' do
+  describe 'comparing combination of same type' do
+    it 'compares combinations' do
+      expect(described_class.new(strongest_combination)).to be > described_class.new(weakest_combination)
+      expect(described_class.new(middle_combination1)).to be < described_class.new(strongest_combination)
+      expect(described_class.new(middle_combination1)).to eq described_class.new(middle_combination2)
+    end
+  end
+end
+

data/spec/combinations/straight_spec.rb

@@ -0,0 +1,56 @@
+require 'rspec'
+
+describe TexasHoldem::Combinations::Straight do
+
+  include_examples 'initialising with empty array'
+
+  context 'when ace is used as low' do
+    include_examples 'setting combination info' do
+      let(:cards) {[ Card.new('2h'), Card.new('Ad'), Card.new('3s'), Card.new('5c'),
+                     Card.new('4d'),  Card.new('Js'), Card.new('Qh') ]}
+      let(:kicker_cards) {[]}
+      let(:combination_cards) {['A♦', '2♥', '3♠', '4♦', '5♣']}
+    end
+  end
+
+  context 'when there is a straight combination' do
+    include_examples 'setting combination info' do
+      let(:cards) {[ Card.new('Jh'), Card.new('Ad'), Card.new('Qs'), Card.new('Kc'),
+                     Card.new('10d'),  Card.new('Js'), Card.new('6h') ]}
+      let(:kicker_cards) {[]}
+      let(:combination_cards) {['10♦', 'J♥', 'Q♠', 'K♣', 'A♦']}
+    end
+  end
+
+  context 'when there is a straight with more than 5 cards' do
+    include_examples 'setting combination info' do
+      let(:cards) {[ Card.new('4h'), Card.new('6d'), Card.new('9s'), Card.new('5c'),
+                     Card.new('7d'),  Card.new('10s'), Card.new('8h') ]}
+      let(:kicker_cards) {[]}
+      let(:combination_cards) {['6♦', '7♦', '8♥', '9♠', '10♠']}
+    end
+  end
+
+  context 'when there is no straight' do
+    include_examples 'setting combination info' do
+      let(:cards) {[ Card.new('4h'), Card.new('6d'), Card.new('9s'), Card.new('5c'),
+                     Card.new('7d'),  Card.new('10s'), Card.new('Jh') ]}
+      let(:kicker_cards) {['J♥', '10♠', '9♠', '7♦', '6♦']}
+      let(:combination_cards) {[]}
+    end
+  end
+
+  include_examples '#has_combination?' do
+    let(:cards_with_combination) {[ Card.new('3h'), Card.new('4h'), Card.new('5d'), Card.new('7d'), Card.new('6c') ]}
+    let(:cards_without_combination) {[ Card.new('4h'), Card.new('6d'), Card.new('9s'), Card.new('5c'),
+                                       Card.new('7d'),  Card.new('10s'), Card.new('Jh') ]}
+  end
+
+  include_examples 'comparing' do
+    let(:strongest_combination) { [Card.new('Qs'), Card.new('Kc'), Card.new('Js'), Card.new('10c'), Card.new('Ac')] }
+    let(:middle_combination1)  { [Card.new('5s'), Card.new('6c'), Card.new('7d'), Card.new('8s'), Card.new('9s')] }
+    let(:middle_combination2) { [ Card.new('9s'), Card.new('8s'), Card.new('7d'), Card.new('6c'), Card.new('5s')] }
+    let(:weakest_combination) { [Card.new('2s'), Card.new('3c'), Card.new('4c'), Card.new('5d'), Card.new('6d')] }
+  end
+
+end

data/spec/combinations/three_of_a_kind_spec.rb

@@ -0,0 +1,36 @@
+require 'rspec'
+
+describe TexasHoldem::Combinations::ThreeOfAKind do
+
+  include_examples 'initialising with empty array'
+
+  context 'when combination is present' do
+    include_examples 'setting combination info' do
+      let(:cards) {[ Card.new('Jh'), Card.new('Ad'), Card.new('Qs'), Card.new('Jc'),
+                     Card.new('3d'),  Card.new('Js'), Card.new('6h') ]}
+      let(:kicker_cards) {['A♦', 'Q♠']}
+      let(:combination_cards) {['J♥', 'J♣', 'J♠']}
+    end
+  end
+
+  context 'when there are no two pairs' do
+    include_examples 'setting combination info' do
+      let(:cards) {[Card.new('Jh'), Card.new('Jd'), Card.new('Ad'), Card.new('As'), Card.new('2s')]}
+      let(:kicker_cards) {['A♦', 'A♠', 'J♥', 'J♦', '2♠']}
+      let(:combination_cards) {[]}
+    end
+  end
+
+  include_examples '#has_combination?' do
+    let(:cards_with_combination) {[ Card.new('Ad'), Card.new('As'), Card.new('Ah'), Card.new('6s') ]}
+    let(:cards_without_combination) {[Card.new('Jh'), Card.new('Ad'), Card.new('6s')]}
+  end
+
+  include_examples 'comparing' do
+    let(:strongest_combination) { [Card.new('As'), Card.new('Ac'), Card.new('As'), Card.new('Kc')] }
+    let(:middle_combination1)  { [Card.new('10s'), Card.new('2c'), Card.new('10d'), Card.new('10s')] }
+    let(:middle_combination2) { [Card.new('10h'), Card.new('2d'), Card.new('10h'), Card.new('10c')] }
+    let(:weakest_combination) { [Card.new('2s'), Card.new('2c'), Card.new('3c'), Card.new('2d')] }
+  end
+
+end

data/spec/combinations/two_pairs_spec.rb

@@ -0,0 +1,49 @@
+require 'rspec'
+
+# ["Q♦", "Q♠"]
+# Cards on table: ["7♣", "A♥", "A♠", "8♥", "7♥"]
+#[Card.new('Qd'),Card.new('Qs'),Card.new('7c'),Card.new('Ah'),Card.new('As'),Card.new('8h'),Card.new('7h')]
+
+describe TexasHoldem::Combinations::TwoPairs do
+
+  include_examples 'initialising with empty array'
+
+  context 'when combination is present' do
+    include_examples 'setting combination info' do
+      let(:cards) {[ Card.new('Jh'), Card.new('Ad'), Card.new('Qs'), Card.new('3c'),
+                     Card.new('3d'),  Card.new('Js'), Card.new('6h') ]}
+      let(:kicker_cards) {['A♦']}
+      let(:combination_cards) {['J♥', 'J♠', '3♣', '3♦']}
+    end
+  end
+
+  context 'when there are no two pairs' do
+    include_examples 'setting combination info' do
+      let(:cards) {[Card.new('Jh'), Card.new('Jd'), Card.new('Ad'), Card.new('6s')]}
+      let(:kicker_cards) {['A♦', 'J♥', 'J♦', '6♠']}
+      let(:combination_cards) {[]}
+    end
+  end
+
+  context 'when there are three pairs' do
+    include_examples 'setting combination info' do
+      let(:cards) { [Card.new('Qd'), Card.new('Qs'), Card.new('7c'), Card.new('Ah'),
+                     Card.new('As'), Card.new('8h'), Card.new('7h')] }
+      let(:kicker_cards) {['8♥']}
+      let(:combination_cards) {['Q♦', 'Q♠', 'A♥', 'A♠']}
+    end
+  end
+
+  include_examples '#has_combination?' do
+    let(:cards_with_combination) {[ Card.new('Ad'), Card.new('As'), Card.new('6h'), Card.new('6s') ]}
+    let(:cards_without_combination) {[Card.new('Jh'), Card.new('Ad'), Card.new('6s')]}
+  end
+
+  include_examples 'comparing' do
+    let(:strongest_combination) { [Card.new('Qs'), Card.new('Qc'), Card.new('2s'), Card.new('2c')] }
+    let(:middle_combination1)  { [Card.new('2s'), Card.new('2c'), Card.new('10d'), Card.new('10s')] }
+    let(:middle_combination2) { [Card.new('5h'), Card.new('5d'), Card.new('10h'), Card.new('10c')] }
+    let(:weakest_combination) { [Card.new('2s'), Card.new('2c'), Card.new('3c'), Card.new('3d')] }
+  end
+
+end

data/spec/player_hand_spec.rb

@@ -0,0 +1,44 @@
+require 'rspec'
+
+describe TexasHoldem::PlayerHand do
+
+  describe '#initialize' do
+    it 'should set best combination' do
+      hand = described_class.new([Card.new('As'), Card.new('2c'), Card.new('8d')])
+      expect(hand.best_combination).to be_instance_of(TexasHoldem::Combinations::HighestCard)
+    end
+
+    it 'should set best combination to nil' do
+      hand = described_class.new([])
+      expect(hand.best_combination).to be_nil
+    end
+  end
+
+  describe '#add_cards' do
+    let(:hand) {described_class.new([])}
+
+    it 'should add one card' do
+      hand.add_cards(Card.new('As'))
+      expect(hand.cards).to eq([Card.new('As')])
+    end
+
+    it 'should add array of cards' do
+      hand.add_cards([Card.new('As'), Card.new('2s')])
+      expect(hand.cards).to eq([Card.new('As'), Card.new('2s')])
+    end
+
+    it 'should update best combination' do
+      hand = described_class.new([Card.new('As')])
+      hand.add_cards([Card.new('As'), Card.new('2s')])
+      expect(hand.best_combination).to be_instance_of(TexasHoldem::Combinations::Pair)
+    end
+  end
+
+  describe '#<=>' do
+    it 'compares two hands by best combination' do
+      hand1 = described_class.new([Card.new('As')])
+      hand2 = described_class.new([Card.new('2s'), Card.new('2h')])
+      expect(hand2).to be > hand1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'texas-holdem'
+Card = TexasHoldem::Card

data/texas-holdem.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |spec|
+  spec.name        = 'texas-holdem'
+  spec.version     = '0.0.0'
+  spec.date        = '2015-06-12'
+  spec.summary     = 'Texas holdem'
+  spec.description = 'Texas holdem'
+  spec.authors     = ['Andrey Chernyshev']
+  spec.email       = 'libpual@yandex.ru'
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ['lib']
+  spec.executables = ['texas-holdem']
+
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: texas-holdem
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Andrey Chernyshev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Texas holdem
+email: libpual@yandex.ru
+executables:
+- texas-holdem
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- bin/texas-holdem
+- lib/texas-holdem.rb
+- lib/texas-holdem/card.rb
+- lib/texas-holdem/combinations/combination.rb
+- lib/texas-holdem/combinations/flush.rb
+- lib/texas-holdem/combinations/highest_card.rb
+- lib/texas-holdem/combinations/pair.rb
+- lib/texas-holdem/combinations/ranks.rb
+- lib/texas-holdem/combinations/straight.rb
+- lib/texas-holdem/combinations/three_of_a_kind.rb
+- lib/texas-holdem/combinations/two_pairs.rb
+- lib/texas-holdem/deck.rb
+- lib/texas-holdem/game.rb
+- lib/texas-holdem/player_hand.rb
+- spec/card_spec.rb
+- spec/combinations/combination_spec.rb
+- spec/combinations/flush_spec.rb
+- spec/combinations/highest_card_spec.rb
+- spec/combinations/pair_spec.rb
+- spec/combinations/shared_combination_examples.rb
+- spec/combinations/straight_spec.rb
+- spec/combinations/three_of_a_kind_spec.rb
+- spec/combinations/two_pairs_spec.rb
+- spec/player_hand_spec.rb
+- spec/spec_helper.rb
+- texas-holdem.gemspec
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Texas holdem
+test_files:
+- spec/card_spec.rb
+- spec/combinations/combination_spec.rb
+- spec/combinations/flush_spec.rb
+- spec/combinations/highest_card_spec.rb
+- spec/combinations/pair_spec.rb
+- spec/combinations/shared_combination_examples.rb
+- spec/combinations/straight_spec.rb
+- spec/combinations/three_of_a_kind_spec.rb
+- spec/combinations/two_pairs_spec.rb
+- spec/player_hand_spec.rb
+- spec/spec_helper.rb