hands 0.0.2 → 0.1.0

data/test/units/hand_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class HandTest < Hands::TestCase
+  def test_ordering_hands
+    pair = Hands::Hand.new
+    pair << Hands::Card[2, :hearts]
+    pair << Hands::Card[2, :clubs]
+
+    flush = Hands::Hand.new
+    flush << Hands::Card[6, :hearts]
+    flush << Hands::Card[7, :hearts]
+    flush << Hands::Card[8, :hearts]
+    flush << Hands::Card[2, :hearts]
+    flush << Hands::Card[4, :hearts]
+    assert flush > pair
+  end
+
+  def test_order_same_hand
+    small_pair = Hands::Hand.new
+    small_pair << Hands::Card[2, :hearts]
+    small_pair << Hands::Card[2, :clubs]
+
+    large_pair = Hands::Hand.new
+    large_pair << Hands::Card['A', :hearts]
+    large_pair << Hands::Card['A', :clubs]
+    assert large_pair > small_pair
+
+    small_kicker = Hands::Hand.new
+    small_kicker << Hands::Card['A', :spades]
+    small_kicker << Hands::Card['A', :diamonds]
+    small_kicker << Hands::Card[2, :diamonds]
+    small_kicker << Hands::Card[3, :diamonds]
+    small_kicker << Hands::Card[4, :diamonds]
+
+    big_kicker = Hands::Hand.new
+    big_kicker << Hands::Card['A', :hearts]
+    big_kicker << Hands::Card['A', :clubs]
+    big_kicker << Hands::Card[10, :diamonds]
+    big_kicker << Hands::Card[9, :diamonds]
+    big_kicker << Hands::Card[7, :diamonds]
+    assert big_kicker > small_kicker
+  end
+
+  def test_collecting_suits
+    hand = Hands::Hand.new
+    hand << Hands::Card[2, :hearts]
+    hand << Hands::Card[2, :clubs]
+    assert_equal [:hearts, :clubs], hand.suits
+
+    hand << Hands::Card[3, :clubs]
+    assert_equal [:hearts, :clubs], hand.suits
+  end
+end

data/test/units/player_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class PlayerTest < Hands::TestCase
+  def test_initialization
+    player1 = Hands::Player.new
+    refute player1.name
+
+    player2 = Hands::Player.new('Sam')
+    assert_equal 'Sam', player2.name
+  end
+end

data/test/units/table_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+class TableTest < Hands::TestCase
+  def setup
+    @sam = Hands::Player.new('Sam')
+    @ian = Hands::Player.new('Ian')
+    @steve = Hands::Player.new('Steve')
+
+    @table = Hands::Table.new
+    @table.players = [@sam, @ian, @steve]
+  end
+
+  def test_dealing
+    @table.deal_player_cards!
+    assert_equal 2, @sam.hand.cards.length
+    assert_equal 2, @ian.hand.cards.length
+    assert_equal 2, @steve.hand.cards.length
+    assert_equal 46, @table.deck.cards.length
+  end
+
+  def test_dealing_with_position
+    cards = @table.deck.cards.dup
+    @table.deal_player_cards!
+    assert_equal [cards.slice(-3, 1), cards.slice(-6, 1)].flatten, @sam.hand.cards
+    assert_equal [cards.slice(-1, 1), cards.slice(-4, 1)].flatten, @ian.hand.cards
+    assert_equal [cards.slice(-2, 1), cards.slice(-5, 1)].flatten, @steve.hand.cards
+
+    @table.new_hand!
+    cards = @table.deck.cards.dup
+    @table.deal_player_cards!
+    assert_equal [cards.slice(-2, 1), cards.slice(-5, 1)].flatten, @sam.hand.cards
+    assert_equal [cards.slice(-3, 1), cards.slice(-6, 1)].flatten, @ian.hand.cards
+    assert_equal [cards.slice(-1, 1), cards.slice(-4, 1)].flatten, @steve.hand.cards
+
+    @table.new_hand!
+    cards = @table.deck.cards.dup
+    @table.deal_player_cards!
+    assert_equal [cards.slice(-1, 1), cards.slice(-4, 1)].flatten, @sam.hand.cards
+    assert_equal [cards.slice(-2, 1), cards.slice(-5, 1)].flatten, @ian.hand.cards
+    assert_equal [cards.slice(-3, 1), cards.slice(-6, 1)].flatten, @steve.hand.cards
+  end
+
+  def test_dealing_the_flop
+    @table.deal_player_cards!
+    @table.deal_flop!
+    assert_equal 42, @table.deck.cards.length
+  end
+
+  def test_dealing_the_turn
+    @table.deal_player_cards!
+    @table.deal_flop!
+    @table.deal_turn!
+    assert_equal 40, @table.deck.cards.length
+  end
+
+  def test_dealing_the_river
+    @table.deal_player_cards!
+    @table.deal_flop!
+    @table.deal_turn!
+    @table.deal_river!
+    assert_equal 38, @table.deck.cards.length
+  end
+
+  def test_resetting
+    @table.deal_player_cards!
+    @table.deal_flop!
+    @table.deal_turn!
+    @table.deal_river!
+    @table.new_hand!
+    assert_equal 0, @sam.hand.cards.length
+    assert_equal 0, @ian.hand.cards.length
+    assert_equal 0, @steve.hand.cards.length
+    assert_equal 52, @table.deck.cards.length
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hands
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,29 +9,39 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-23 00:00:00.000000000 Z
+date: 2013-01-22 00:00:00.000000000 Z
 dependencies: []
 description: Simple library for various poker hands calculations.
 email:
-- sam@samsoff.es
+- sam@soff.es
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .yardopts
 - Gemfile
 - LICENSE
 - Rakefile
 - Readme.markdown
+- Todo.markdown
 - hands.gemspec
 - lib/hands.rb
 - lib/hands/card.rb
+- lib/hands/deck.rb
 - lib/hands/hand.rb
+- lib/hands/hand_detection.rb
+- lib/hands/player.rb
+- lib/hands/table.rb
 - lib/hands/version.rb
-- spec/models/card_spec.rb
-- spec/models/hand_spec.rb
-- spec/spec_helper.rb
-homepage: http://github.com/samsoffes/hands
+- test/test_helper.rb
+- test/units/card_test.rb
+- test/units/deck_test.rb
+- test/units/hand_detection_test.rb
+- test/units/hand_test.rb
+- test/units/player_test.rb
+- test/units/table_test.rb
+homepage: http://github.com/soffes/hands
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -43,19 +53,30 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 3489635347020004355
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 3489635347020004355
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Simple library for various poker hands calculations.
 test_files:
-- spec/models/card_spec.rb
-- spec/models/hand_spec.rb
-- spec/spec_helper.rb
+- test/test_helper.rb
+- test/units/card_test.rb
+- test/units/deck_test.rb
+- test/units/hand_detection_test.rb
+- test/units/hand_test.rb
+- test/units/player_test.rb
+- test/units/table_test.rb
+has_rdoc: 

data/spec/models/card_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe Hands::Card do
-  it 'should validate cards' do
-    card = Hands::Card.new
-    card.is_valid?.should eq(false)
-    card.is_invalid?.should eq(true)
-
-    card.suite = :hearts
-    card.is_valid?.should eq(false)
-
-    card.value = 9
-    card.is_valid?.should eq(true)
-
-    card.suite = 17
-    card.is_valid?.should eq(false)
-  end
-
-  it 'should allow for integers instead of characters for high cards' do
-    card1 = Hands::Card.new(:value => 11, :suite => :clubs)
-    card1.is_valid?.should eq(true)
-    card1.value.should eq('j')
-
-    card2 = Hands::Card.new(:value => 'j', :suite => :clubs)
-    card2.should eq(card1)
-  end
-
-  it 'should not allow invalid values' do
-    card = Hands::Card.new
-    card.value = 'p'
-    card.value.should eql(nil)
-  end
-
-  it 'should be comparable' do
-    card1 = Hands::Card.new(:value => 2, :suite => :hearts)
-    card2 = Hands::Card.new(:value => 3, :suite => :clubs)
-
-    (card2 > card1).should eq(true)
-    (card1 < card2).should eq(true)
-
-    card1.value = 3
-    (card1 == card2).should eq(true)
-    (card1.<=>(card2, true)).should eq(1)
-    (card2.<=>(card1, true)).should eq(-1)
-  end
-
-  it 'should be sortable' do
-    c2 = Hands::Card.new(:value => 2, :suite => :hearts)
-    c3 = Hands::Card.new(:value => 3, :suite => :hearts)
-    c4 = Hands::Card.new(:value => 4, :suite => :hearts)
-    c5 = Hands::Card.new(:value => 5, :suite => :hearts)
-    c6 = Hands::Card.new(:value => 6, :suite => :hearts)
-    c7 = Hands::Card.new(:value => 7, :suite => :hearts)
-    c8 = Hands::Card.new(:value => 8, :suite => :hearts)
-    c9 = Hands::Card.new(:value => 9, :suite => :hearts)
-    c10 = Hands::Card.new(:value => 10, :suite => :hearts)
-    cJ = Hands::Card.new(:value => 'j', :suite => :hearts)
-    cQ = Hands::Card.new(:value => 'q', :suite => :hearts)
-    cK = Hands::Card.new(:value => 'k', :suite => :hearts)
-    cA = Hands::Card.new(:value => 'a', :suite => :hearts)
-
-    cards = [c2, c3, c4, c5, c6, c7, c8, c9, c10, cJ, cQ, cK, cA]
-    cards.sort.should eq(cards)    
-  end
-
-  it 'should include description in inspect' do
-    card = Hands::Card[2, :hearts]
-    card.inspect.include?('Two of Hearts').should eql(true)
-
-    card = Hands::Card.new
-    card.description.should eql('invalid')
-    card.inspect.include?('invalid').should eql(false)
-  end
-end

data/spec/models/hand_spec.rb

@@ -1,181 +0,0 @@
-require 'spec_helper'
-
-describe Hands::Hand do
-  it 'should order different types of hands' do
-    pair = Hands::Hand.new
-    pair << Hands::Card[2, :hearts]
-    pair << Hands::Card[2, :clubs]
-
-    flush = Hands::Hand.new
-    flush << Hands::Card[6, :hearts]
-    flush << Hands::Card[7, :hearts]
-    flush << Hands::Card[8, :hearts]
-    flush << Hands::Card[2, :hearts]
-    flush << Hands::Card[4, :hearts]
-    (flush > pair).should eq(true)
-  end
-
-  it 'should order same types of hands' do
-    small_pair = Hands::Hand.new
-    small_pair << Hands::Card[2, :hearts]
-    small_pair << Hands::Card[2, :clubs]
-
-    large_pair = Hands::Hand.new
-    large_pair << Hands::Card['A', :hearts]
-    large_pair << Hands::Card['A', :clubs]
-    (large_pair > small_pair).should eq(true)
-
-    small_kicker = Hands::Hand.new
-    small_kicker << Hands::Card['A', :spades]
-    small_kicker << Hands::Card['A', :diamonds]
-    small_kicker << Hands::Card[2, :diamonds]
-    small_kicker << Hands::Card[3, :diamonds]
-    small_kicker << Hands::Card[4, :diamonds]
-
-    big_kicker = Hands::Hand.new
-    big_kicker << Hands::Card['A', :hearts]
-    big_kicker << Hands::Card['A', :clubs]
-    big_kicker << Hands::Card[10, :diamonds]
-    big_kicker << Hands::Card[9, :diamonds]
-    big_kicker << Hands::Card[7, :diamonds]
-    (big_kicker > small_kicker).should eq(true)
-  end
-
-  it 'should collect suites' do
-    hand = Hands::Hand.new
-    hand << Hands::Card[2, :hearts]
-    hand << Hands::Card[2, :clubs]
-    hand.suites.should eq([:hearts, :clubs])
-
-    hand << Hands::Card[3, :clubs]
-    hand.suites.should eq([:hearts, :clubs])
-  end
-
-  it 'should recognize high card' do
-    hand = Hands::Hand.new
-    hand << Hands::Card[2, :hearts]
-    hand << Hands::Card[9, :clubs]
-    hand << Hands::Card[7, :hearts]
-    hand << Hands::Card['a', :spades]
-    hand << Hands::Card[4, :diamonds]
-    hand.high_card.collect(&:value).should eq(['a', 9, 7, 4, 2])
-    hand.pair.should eql(nil)
-    hand.two_pair.should eql(nil)
-  end
-
-  it 'should recognize a pair' do
-    hand = Hands::Hand.new
-    hand << Hands::Card[9, :hearts]
-    hand << Hands::Card[9, :clubs]
-    hand << Hands::Card[7, :hearts]
-    hand << Hands::Card[2, :spades]
-    hand << Hands::Card[4, :diamonds]
-    hand.pair.collect(&:value).should eq([9, 9, 7, 4, 2])
-    hand.two_pair.should eql(nil)
-  end
-
-  it 'should recognize two pair'  do
-    hand = Hands::Hand.new
-    hand << Hands::Card[7, :hearts]
-    hand << Hands::Card[7, :spades]
-    hand << Hands::Card[4, :diamonds]
-    hand << Hands::Card[9, :hearts]
-    hand << Hands::Card[9, :clubs]
-    hand.two_pair.collect(&:value).should eq([9, 9, 7, 7, 4])
-    hand.two_pair.should eql(hand.pair)
-  end
-
-  it 'should recognize three of a kind' do
-    hand = Hands::Hand.new
-    hand << Hands::Card[7, :hearts]
-    hand << Hands::Card[7, :spades]
-    hand << Hands::Card[7, :diamonds]
-    hand << Hands::Card[3, :hearts]
-    hand << Hands::Card[9, :clubs]
-    hand.best_hand[:type].should eq('three_of_a_kind')
-  end
-
-  it 'should recognize a straight' do
-    hand1 = Hands::Hand.new
-    hand1 << Hands::Card[2, :hearts]
-    hand1 << Hands::Card[3, :spades]
-    hand1 << Hands::Card[4, :diamonds]
-    hand1 << Hands::Card[5, :hearts]
-    hand1 << Hands::Card[6, :clubs]
-    hand1.best_hand[:type].should eq('straight')
-
-    hand2 = Hands::Hand.new
-    hand2 << Hands::Card['A', :hearts]
-    hand2 << Hands::Card[2, :spades]
-    hand2 << Hands::Card[3, :diamonds]
-    hand2 << Hands::Card[4, :hearts]
-    hand2 << Hands::Card[5, :clubs]
-    hand2.best_hand[:type].should eq('straight')
-
-    hand3 = Hands::Hand.new
-    hand3 << Hands::Card[10, :hearts]
-    hand3 << Hands::Card['J', :spades]
-    hand3 << Hands::Card['Q', :diamonds]
-    hand3 << Hands::Card['K', :hearts]
-    hand3 << Hands::Card['A', :clubs]
-    hand3.best_hand[:type].should eq('straight')
-
-    hand4 = Hands::Hand.new
-    hand4 << Hands::Card['J', :spades]
-    hand4 << Hands::Card['Q', :diamonds]
-    hand4 << Hands::Card['K', :hearts]
-    hand4 << Hands::Card['A', :clubs]
-    hand4 << Hands::Card[2, :hearts]  
-    hand4.best_hand[:type].should eq('high_card')
-  end
-
-  it 'should recognize a flush' do
-    hand = Hands::Hand.new
-    hand << Hands::Card[6, :hearts]
-    hand << Hands::Card[7, :hearts]
-    hand << Hands::Card[8, :hearts]
-    hand << Hands::Card[2, :hearts]
-    hand << Hands::Card[4, :hearts]
-    hand.best_hand[:type].should eq('flush')
-  end
-
-  it 'should recognize a full house' do
-    hand = Hands::Hand.new
-    hand << Hands::Card[7, :hearts]
-    hand << Hands::Card[7, :spades]
-    hand << Hands::Card[7, :diamonds]
-    hand << Hands::Card[9, :spades]
-    hand << Hands::Card[9, :clubs]
-    hand.best_hand[:type].should eq('full_house')
-  end
-
-  it 'should recognize four of a kind' do
-    hand = Hands::Hand.new
-    hand << Hands::Card[7, :hearts]
-    hand << Hands::Card[7, :spades]
-    hand << Hands::Card[7, :diamonds]
-    hand << Hands::Card[7, :clubs]
-    hand << Hands::Card[9, :clubs]
-    hand.best_hand[:type].should eq('four_of_a_kind')
-  end
-
-  it 'should recognize a straight flush' do
-    hand = Hands::Hand.new
-    hand << Hands::Card[2, :hearts]
-    hand << Hands::Card[3, :hearts]
-    hand << Hands::Card[4, :hearts]
-    hand << Hands::Card[5, :hearts]
-    hand << Hands::Card[6, :hearts]
-    hand.best_hand[:type].should eq('straight_flush')
-  end
-
-  it 'should recognize the best hand'  do
-    hand = Hands::Hand.new
-    hand << Hands::Card[7, :hearts]
-    hand << Hands::Card[7, :spades]
-    hand << Hands::Card[4, :diamonds]
-    hand << Hands::Card[9, :hearts]
-    hand << Hands::Card[9, :clubs]
-    hand.best_hand[:type].should eq('two_pair')
-  end
-end