ruby_holdem 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29fbffb1efbe129bc60cc9b38ef8f048c2e18ab9
+  data.tar.gz: 0b99f0a5ebf3996ae2fe11b169647cf1dd74384b
+SHA512:
+  metadata.gz: c4b072056f11a740fe63f29deceb02a692114c152b6532ccb83364757b83728f7cb4425f063f8baeee3373672a31eaf6944a748b42dc9ee35a3c155b8b4bd172
+  data.tar.gz: 409610a9e35b4ec60cfb4730edea0ca4d7958f53682e20b039a502d2d2e3264f89c4d8e26327f577f023324facf3112340c77b4fa922d4bc046068cb76036e8e

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in poker_game.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    ruby_holdem (0.0.1)
+      ruby-poker
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    method_source (0.8.2)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.0)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-its (1.1.0)
+      rspec-core (>= 3.0.0)
+      rspec-expectations (>= 3.0.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    ruby-poker (1.0.1)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.7)
+  pry
+  rake (~> 10.0)
+  rspec
+  rspec-its
+  ruby_holdem!
+
+BUNDLED WITH
+   1.12.5

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016, Evan Rolfe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# RubyHoldem
+RubyHoldem is a set of classes which track the game state of a texas holdem poker game.
+
+### Installation
+```
+git clone git@github.com:evanrolfe/ruby-holdem.git
+cd ruby-holdem/
+gem install ruby_holdem
+```
+
+### Usage
+```ruby
+require 'ruby_holdem'
+
+players = ["Jack", "Joe", "Jil"]
+poker_round = RubyHoldem::Round.new(players, 2, 4)
+
+poker_round.make_move('bet', 2) # Jack bets small blinds
+poker_round.make_move('bet', 4) # Joe bets big blinds
+poker_round.make_move('fold') # Jil folds
+poker_round.make_move('call') # Jack calls
+poker_round.make_move('call') # Joe calls
+poker_round.next_stage
+
+puts poker_round.community_cards.join(' ')
+# => i.e. 3s Js Qd
+
+puts poker_round.pot_amount
+# => 8
+
+poker_round.make_move('bet', 3) # Jack bets 3
+poker_round.make_move('fold') # Joe folds
+
+puts poker_round.winner
+# => Jack
+```
+
+### License
+
+RubyHoldem uses the MIT license. Please check the [LICENSE](https://github.com/evanrolfe/ruby-holdem/blob/master/LICENSE) file for more details.

data/Rakefile.rb

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/example_game.rb

@@ -0,0 +1,44 @@
+require 'ruby_holdem'
+require 'ostruct'
+
+line_break = "\n----------------------\n"
+
+player1 = OpenStruct.new(name: "Player #1")
+player2 = OpenStruct.new(name: "Player #2")
+player3 = OpenStruct.new(name: "Player #3")
+players = [player1, player2, player3]
+
+poker_round = RubyHoldem::Round.new(players, 2, 4)
+
+puts "Game started"
+
+until poker_round.has_winner?
+  puts "#{line_break}#{poker_round.current_stage} , pot: $#{poker_round.pot_amount}"
+  if poker_round.community_cards.any?
+    puts "Community cards: #{poker_round.community_cards.join(' ')}#{line_break}"
+  end
+
+  until poker_round.ready_for_next_stage?
+    next_move_args = [
+        ['bet', 4],
+        ['call'],
+        ['fold']
+      ].sample
+
+    poker_round.make_move(*next_move_args)
+
+    if poker_round.last_move[:move] == 'bet'
+      puts "Player #{poker_round.last_move[:player].name} raised by #{poker_round.last_move[:amount]}"
+    elsif poker_round.last_move[:move] == 'call'
+      puts "Player #{poker_round.last_move[:player].name} called by #{poker_round.last_move[:amount]}"
+    else
+      puts "Player #{poker_round.last_move[:player].name} folded"
+    end
+
+    sleep 0.3
+  end
+
+  poker_round.next_stage
+end
+
+puts "The winner is #{poker_round.winner.name}!"

data/lib/ruby_holdem/dealer.rb

@@ -0,0 +1,28 @@
+module RubyHoldem
+  class Dealer
+    attr_reader :community_cards
+
+    def initialize
+      @deck = Deck.new
+      @deck.shuffle
+      @community_cards = []
+    end
+
+    def deal_hole_cards(players)
+      raise ArgumentError unless players.map { |player| player.hole_cards.count == 0 }.all?
+      players.each do |player|
+        2.times { player.hole_cards << @deck.deal }
+      end
+    end
+
+    def deal_community_cards(stage)
+      raise ArgumentError unless %w(pre_flop flop turn river show_down).include?(stage)
+
+      if stage == 'flop'
+        3.times { community_cards << @deck.deal }
+      elsif %w(turn river).include?(stage)
+        community_cards << @deck.deal
+      end
+    end
+  end
+end

data/lib/ruby_holdem/deck.rb

@@ -0,0 +1,51 @@
+# Code taken from: https://github.com/robolson/ruby-poker/blob/master/examples/deck.rb
+
+module RubyHoldem
+  class Deck
+    def initialize
+      @cards = []
+      Card::SUITS.each_byte do |suit|
+        # careful not to double include the aces...
+        Card::FACES[1..-1].each_byte do |face|
+          @cards.push(Card.new(face.chr, suit.chr))
+        end
+      end
+      shuffle
+    end
+
+    def shuffle
+      @cards = @cards.sort_by { rand }
+      return self
+    end
+
+    # removes a single card from the top of the deck and returns it
+    # synonymous to poping off a stack
+    def deal
+      @cards.pop
+    end
+
+    # delete an array or a single card from the deck
+    # converts a string to a new card, if a string is given
+    def burn(burn_cards)
+      return false if burn_cards.is_a?(Integer)
+      if burn_cards.is_a?(Card) || burn_cards.is_a?(String)
+        burn_cards = [burn_cards]
+      end
+
+      burn_cards.map! do |c|
+        c = Card.new(c) unless c.class == Card
+        @cards.delete(c)
+      end
+      true
+    end
+
+    # return count of the remaining cards
+    def size
+      @cards.size
+    end
+
+    def empty?
+      @cards.empty?
+    end
+  end
+end

data/lib/ruby_holdem/errors.rb

@@ -0,0 +1,7 @@
+module RubyHoldem
+  class MinBetNotMeet < StandardError
+  end
+
+  class NotEnoughMoney < StandardError
+  end
+end

data/lib/ruby_holdem/game.rb

@@ -0,0 +1,5 @@
+module RubyHoldem
+  class Game
+    # TODO: Keep track of an entire poker game consisting of multiple rounds
+  end
+end

data/lib/ruby_holdem/round.rb

@@ -0,0 +1,154 @@
+require 'forwardable'
+
+module RubyHoldem
+  class Round
+    extend Forwardable
+
+    attr_reader :players,
+                :small_blinds,
+                :big_blinds,
+                :pot_amount,
+                :current_stage,
+                :action_history,
+                :dealer,
+                :turns_played
+
+    def_delegator :@dealer, :community_cards
+
+    STAGES = %w(pre_flop flop turn river show_down)
+
+    def initialize(players, small_blinds, big_blinds)
+      @small_blinds, @big_blinds = small_blinds, big_blinds
+      @current_stage = STAGES[0]
+      @pot_amount = 0
+      @action_history = []
+
+      @players = players.map { |player| RoundPlayer.new(player) }
+      @dealer = Dealer.new
+      @dealer.deal_hole_cards(@players)
+    end
+
+    # TODO: Extract the code relating to making a move into its own class to separate the logic
+    #       behind making a move and the game state methods
+    def make_move(move, amount=nil)
+      if turns_played == 0
+        apply_bet(small_blinds)
+      elsif turns_played == 1
+        apply_bet(big_blinds)
+      elsif move == 'bet'
+        apply_bet(amount)
+      elsif move == 'call'
+        apply_call
+      elsif move == 'fold'
+        apply_fold
+      end
+    end
+
+    def next_stage
+      raise StandardError unless ready_for_next_stage? && @current_stage != 'show_down'
+
+      @current_stage = STAGES[STAGES.index(@current_stage)+1]
+      @dealer.deal_community_cards(@current_stage)
+    end
+
+    def ready_for_next_stage?
+      return false unless every_player_has_called? && turns_played_in_stage > 0
+
+      players_still_in_round.map { |player| (player.current_bet_amount == highest_bet_placed) }.all?
+    end
+
+    def has_winner?
+      (current_stage == 'show_down' || players_still_in_round.count == 1)
+    end
+
+    def winner
+      return players_still_in_round[0] if players_still_in_round.count == 1
+      return players_still_in_round[2]
+    end
+
+    # TODO: Refactor this method to make it more readable
+    def player_in_turn  #The player whose turn it is to make a move
+      return players[0] if action_history.length == 0
+
+      last_player_index = players.index(action_history.last[:player])
+      player_found = false
+      increment=1
+
+      until player_found
+        next_player = players[(last_player_index + increment) % players.length]   #Wrap around the array once end reached
+        player_found = true if players_still_in_round.include?(next_player)
+        increment += 1
+      end
+
+      next_player
+    end
+
+    def players_still_in_round
+      players.select do |round_player|
+        folds = action_history.select { |action| action[:move] == 'fold' && action[:player] == round_player }
+        (folds.length == 0)
+      end
+    end
+
+    def highest_bet_placed
+      players_still_in_round.max_by(&:current_bet_amount).current_bet_amount
+    end
+
+    def last_move
+      action_history.last
+    end
+
+    private
+
+    def turns_played
+      action_history.length
+    end
+
+    def turns_played_in_stage
+      action_history.select { |action| action[:stage] == @current_stage }.length
+    end
+
+    def every_player_has_called?
+      players_num_calls = players_still_in_round.map do |round_player|
+        calls = action_history.select { |action| action[:stage] == @current_stage && action[:move] == 'call' && action[:player] == round_player }
+        calls.length
+      end
+
+      players_num_calls.map { |num_calls| num_calls >= 1 }.all?
+    end
+
+    def apply_bet(amount)
+      raise MinBetNotMeet if amount < min_bet_amount_for_player(player_in_turn)
+
+      #TODO: Go all in instead of raising an error
+      raise NotEnoughMoney unless player_can_afford_bet?(player_in_turn, amount)
+
+      @pot_amount += amount
+      player_in_turn.current_bet_amount += amount
+      action_history << { player: player_in_turn, stage: current_stage, move: 'bet', amount: amount}
+    end
+
+    def apply_call
+      amount = min_bet_amount_for_player(player_in_turn)
+      raise NotEnoughMoney unless player_can_afford_bet?(player_in_turn, amount)
+
+      @pot_amount += amount
+      player_in_turn.current_bet_amount += amount
+
+      action_history << { player: player_in_turn, stage: current_stage, move: 'call', amount: amount}
+    end
+
+    def apply_fold
+      action_history << { player: player_in_turn, stage: current_stage, move: 'fold', amount: 0}
+    end
+
+    def min_bet_amount_for_player(player)
+      highest_bet_placed - player.current_bet_amount
+    end
+
+    # TODO:
+    def player_can_afford_bet?(player, bet_amount)
+      true
+    end
+  end
+end

data/lib/ruby_holdem/round_player.rb

@@ -0,0 +1,11 @@
+module RubyHoldem
+  class RoundPlayer < SimpleDelegator
+    attr_accessor :hole_cards, :current_bet_amount
+
+    def initialize(player)
+      @hole_cards = []
+      @current_bet_amount = 0
+      super(player)
+    end
+  end
+end

data/lib/ruby_holdem/version.rb

@@ -0,0 +1,3 @@
+module RubyHoldem
+  VERSION = "0.0.1"
+end

data/lib/ruby_holdem.rb

@@ -0,0 +1,7 @@
+require 'ruby-poker'
+require 'ruby_holdem/deck'
+require 'ruby_holdem/errors'
+
+require 'ruby_holdem/dealer'
+require 'ruby_holdem/round'
+require 'ruby_holdem/round_player'

data/ruby_holdem.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'ruby_holdem/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ruby_holdem'
+  spec.version       = RubyHoldem::VERSION
+  spec.authors       = ['Evan Rolfe']
+  spec.email         = ['evanrolfe@gmail.com']
+  spec.summary       = 'A gem for playing texas-holdem poker'
+  spec.homepage      = 'https://github.com/evanrolfe/ruby-holdem'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = []
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'ruby-poker'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec-its'
+end

data/spec/dealer_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe RubyHoldem::Dealer do
+  pending
+end

data/spec/round_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe RubyHoldem::Round do
+  let(:player1) { OpenStruct.new(name: "Player #1") }
+  let(:player2) { OpenStruct.new(name: "Player #2") }
+  let(:player3) { OpenStruct.new(name: "Player #3") }
+  let(:players) { [player1, player2, player3] }
+
+  let(:round) { RubyHoldem::Round.new(players, 1, 2) }
+
+  describe '#initialize' do
+    subject { round }
+
+    # TODO: Convert all instances of "should" to "is_expected"
+    its(:small_blinds) { should eq(1) }
+    its(:big_blinds) { should eq(2) }
+    its(:current_stage) { should eq('pre_flop') }
+    its(:action_history) { should eq([]) }
+  end
+
+  describe '#next_stage' do
+    before do
+      allow(round).to receive(:action_history).and_return(action_history)
+    end
+
+    context 'on the pre_flop' do
+      # TODO: Convert the stubbing of the action_history to a sequence of make_move calls in a
+      #       before block
+      let(:action_history) do
+        [
+          { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
+          { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' },
+          { stage: 'pre_flop', player: round.players[2], amount: 1, move: 'call' },
+          { stage: 'pre_flop', player: round.players[0], amount: 0, move: 'call' }
+        ]
+      end
+
+      before do
+        round.next_stage
+      end
+
+      it { expect(round.current_stage).to eq('flop') }
+    end
+  end
+
+  describe '#ready_for_next_stage?' do
+    before do
+      allow(round).to receive(:action_history).and_return(action_history)
+    end
+
+    subject { round.ready_for_next_stage? }
+
+    context 'on game start' do
+      let(:action_history) { [] }
+
+      it { should eq(false) }
+    end
+
+    context 'on the pre_flop' do
+
+      context 'situation 1' do
+        let(:action_history) do
+          [
+            { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
+            { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' }
+          ]
+        end
+        it { should eq(false) }
+      end
+
+      context 'situation 2' do
+        let(:action_history) do
+          [
+            { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
+            { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' },
+            { stage: 'pre_flop', player: round.players[2], amount: 1, move: 'call' },
+            { stage: 'pre_flop', player: round.players[0], amount: 0, move: 'call' }
+          ]
+        end
+
+        it { should eq(true) }
+      end
+
+    end
+
+    context 'on the flop' do
+
+      context 'situation 1' do
+        let(:action_history) do
+          [
+            { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
+            { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' },
+            { stage: 'pre_flop', player: round.players[2], amount: 1, move: 'call' },
+            { stage: 'flop', player: round.players[0], amount: 1, move: 'bet' }
+          ]
+        end
+
+        before do
+          allow(round).to receive(:current_stage).and_return('flop')
+        end
+
+        it { should eq(false) }
+      end
+
+      context 'situation 2' do
+        let(:action_history) do
+          [
+            { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
+            { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' },
+            { stage: 'pre_flop', player: round.players[2], amount: 1, move: 'call' },
+            { stage: 'pre_flop', player: round.players[0], amount: 0, move: 'call' },
+            { stage: 'flop', player: round.players[0], amount: 3, move: 'bet' },
+            { stage: 'flop', player: round.players[2], amount: 3, move: 'call' },
+            { stage: 'flop', player: round.players[0], amount: 0, move: 'call' }
+          ]
+        end
+
+        before do
+          allow(round).to receive(:current_stage).and_return('flop')
+        end
+
+        it { should eq(true) }
+      end
+
+    end
+  end
+
+  describe '#player_in_turn' do
+    let(:action_history) do
+      [
+        { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
+        { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' }
+      ]
+    end
+
+    before do
+      allow(round).to receive(:action_history).and_return(action_history)
+    end
+
+    subject { round.send(:player_in_turn) }
+
+    it { should == round.players[2] }
+  end
+
+  describe '#players_still_in_round' do
+    let(:action_history) do
+      [
+        { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
+        { stage: 'pre_flop', player: round.players[1], amount: 0, move: 'fold' }
+      ]
+    end
+
+    before do
+      allow(round).to receive(:action_history).and_return(action_history)
+    end
+
+    subject { round.send(:players_still_in_round) }
+
+    its([0]) { should eq(round.players[0]) }
+    its([1]) { should eq(round.players[2]) }
+  end
+
+  describe '#highest_bet_placed' do
+    before do
+      round.make_move('call')
+      round.make_move('call')
+      round.make_move('bet', 4)
+    end
+
+    subject { round.send(:highest_bet_placed) }
+
+    it { should eq(4) }
+  end
+
+  describe '#has_winner?' do
+    subject { round.has_winner? }
+
+    context 'round won after folds' do
+      let(:action_history) do
+        [
+          { stage: 'pre_flop', player: round.players[0], amount: 1, move: 'bet' },
+          { stage: 'pre_flop', player: round.players[1], amount: 4, move: 'bet' },
+          { stage: 'pre_flop', player: round.players[2], amount: 0, move: 'fold'},
+          { stage: 'pre_flop', player: round.players[0], amount: 3, move: 'call' },
+          { stage: 'flop', player: round.players[1], amount: 0, move: 'call' },
+          { stage: 'flop', player: round.players[0], amount: 0, move: 'fold' }
+        ]
+      end
+
+      before do
+        allow(round).to receive(:action_history).and_return(action_history)
+      end
+
+      it { should eq(true) }
+    end
+
+    context 'showdown between remaining players' do
+      before do
+        allow(round).to receive(:current_stage).and_return('show_down')
+      end
+
+      it { should eq(true) }
+    end
+  end
+
+  describe '#winner' do
+
+  end
+
+  describe '#apply_bet' do
+    context 'at the start of the round' do
+      before do
+        round.send(:apply_bet, 1)
+      end
+
+      subject { round }
+
+      its(:action_history) { should eq([{ player: round.players[0], stage: 'pre_flop', move: 'bet', amount: 1 }]) }
+      its(:pot_amount) {  should eq(1) }
+    end
+  end
+
+  describe '#apply_call' do
+    context 'at the start of the round' do
+      before do
+        round.send(:apply_call)
+      end
+
+      subject { round }
+
+      its(:action_history) { should eq([{ player: round.players[0], stage: 'pre_flop', move: 'call', amount: 0 }]) }
+      its(:pot_amount) {  should eq(0) }
+    end
+  end
+
+  describe '#apply_fold' do
+    context 'at the start of the round' do
+      before do
+        round.send(:apply_fold)
+      end
+
+      subject { round }
+
+      its(:action_history) { should eq([{ player: round.players[0], stage: 'pre_flop', move: 'fold', amount: 0 }]) }
+      its(:pot_amount) {  should eq(0) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rspec'
+require 'rspec/its'
+require 'pry'
+require 'ruby_holdem'
+
+RSpec.configure do |config|
+  config.color = true
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: ruby_holdem
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Evan Rolfe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-poker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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-its
+  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: 
+email:
+- evanrolfe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile.rb
+- example_game.rb
+- lib/ruby_holdem.rb
+- lib/ruby_holdem/dealer.rb
+- lib/ruby_holdem/deck.rb
+- lib/ruby_holdem/errors.rb
+- lib/ruby_holdem/game.rb
+- lib/ruby_holdem/round.rb
+- lib/ruby_holdem/round_player.rb
+- lib/ruby_holdem/version.rb
+- ruby_holdem.gemspec
+- spec/dealer_spec.rb
+- spec/round_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/evanrolfe/ruby-holdem
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A gem for playing texas-holdem poker
+test_files:
+- spec/dealer_spec.rb
+- spec/round_spec.rb
+- spec/spec_helper.rb