card_nine 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 854dfb09dcd2e62f7ec6b5c965862bb9f962753b
-  data.tar.gz: 9f052c35d78081007e70e590297399bd45aea9f9
+  metadata.gz: fc6e81abfc7d2342293b27bd817dc6d3efd7dc6d
+  data.tar.gz: 443536f808e04a8ee0e1b04eb30fe2468aa276cb
 SHA512:
-  metadata.gz: 84002ce61aa852ffd44c0d75e20fa0718595248bd02175d78ad3fab7ceda2ab3f8a6b3d5d9a28d779809ee2000e263c8aafa8de768be3c82cf2f29b281220b9e
-  data.tar.gz: 9d195cbcb17037dab55d72f8fa4f3180525342f242ba1c608d18f4315371864161827ce355d0f34bbac8e5d7b8d968bc925b50a2af468bcaa335b3a9d5ec681d
+  metadata.gz: 841fa6dae3ce1dd5b2dfd0bbffb7ce6795691b1fdada683304590a136f3ef5505828e8ee07cc6a6a7b432e67316fc1bf791d8824073ee797146fe44a2ba08df3
+  data.tar.gz: 53a22aadba21b045dc72073cc1bf851d6ec50d95165e3ab2c28b778ffe137b0669150e331930a55d097d4914224d73ee611da7be83fc2f503fab77c63bdaf581

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.5.0

data/lib/card_nine.rb

@@ -6,8 +6,5 @@
 module CardNine
   require 'card_nine/card'
   require 'card_nine/deck'
-  require 'card_nine/dealer'
-  require 'card_nine/table'
-  require 'card_nine/hand'
 
 end

data/lib/card_nine/dealer.rb

@@ -1,4 +1,18 @@
 module CardNine
   class Dealer
+
+    attr_reader :deck, :locations, :stages
+
+    def initialize(deck, locations, stages = {})
+      @deck      = deck
+      @locations = locations
+      @stages    = stages
+    end
+
+    def deal(players)
+      Table.new(deck.shuffle, players, locations, stages)
+    end
+
+
   end
 end

data/lib/card_nine/dealers/simple.rb

@@ -0,0 +1,11 @@
+require 'card_nine/table'
+require 'card_nine/dealer'
+
+module CardNine
+  module Dealers
+    class Simple < CardNine::Dealer
+
+
+    end
+  end
+end

data/lib/card_nine/dealers/texas_holdem.rb

@@ -1,4 +1,7 @@
 require 'card_nine/cards/playing_card'
+require 'card_nine/dealer'
+require 'card_nine/table'
+
 module CardNine
   module Dealers
     # implements a CardNine::Dealer for the game of Texas Holdem.  This is only
@@ -18,29 +21,21 @@ module CardNine
     #   wagering(:round, hand)
     # end
     # wager(:resolve, hand)
-    class TexasHoldem
-
-      attr_accessor :players, :deck
+    class TexasHoldem < CardNine::Dealer
 
       STAGES = {
-          deal_hole_cards: ->(h) { h.deal_players(2) },
-          flop:            ->(h) { h.discard; h.deal(3, to: :community) },
-          turn:            ->(h) { h.discard; h.deal(to: :community) },
-          river:           ->(h) { h.discard; h.deal(to: :community) }
+          deal_hole_cards: ->(t) { t.deal_players(2) },
+          flop:            ->(t) { t.discard; t.deal(3, to: :community) },
+          turn:            ->(t) { t.discard; t.deal(to: :community) },
+          river:           ->(t) { t.discard; t.deal(to: :community) },
+          fold:            ->(t, p) { t.remove_player(p) }
       }
 
-      def initialize(players:, deck: CardNine::Cards::PlayingCard.deck)
-        @players = players
-        @deck    = deck
-      end
-
-      # generate a new hand from this dealer
-      # @return [CardNine::Hand]
-      def new_hand
-        players.rotate!
-        Hand.start(players: players, deck: deck, stages: STAGES)
+      def initialize
+        super CardNine::Cards::PlayingCard.deck, [:community], STAGES
       end
 
     end
+
   end
 end

data/lib/card_nine/deck.rb

@@ -1,13 +1,9 @@
+require 'virtus'
 module CardNine
   class Deck
-    # @!method initialize(args = nil)
-    #   will set the instance vars using the keys of args as a attribute name
-    #   @param [Hash, Nil] args
     include Virtus.model
 
-    # @!attribute [rw] cards
-    #   @return [Array<Card>] all cards in the deck
-    attribute :cards, Array[Card], default: []
+    attribute :cards, Array, default: []
 
     # @!attribute [rw] rng
     #   @return [Random,#rand]
@@ -15,7 +11,7 @@ module CardNine
 
     # @return Array[Card] randomized
     def shuffle
-      cards.shuffle(random: rng)
+      cards.shuffle!(random: rng)
     end
   end
 end

data/lib/card_nine/table.rb

@@ -1,38 +1,48 @@
-require 'virtus'
 module CardNine
-  # a CardNine::Table is the shoe, discard pile, and player hands
   class Table
-    include Virtus.model
+    attr_reader :shoe, :players, :hands, :locations, :discards, :stages
 
-    # @!attribute [rw] deck
-    #   @return [CardNine::Deck, #shuffle]
-    attribute :deck
+    def initialize(shoe, players, locations, stages = {})
+      @shoe      = shoe
+      @players   = players
+      @locations = locations
+      @discards  = []
+      @stages    = stages
+      @hands     = { shoe: @shoe, discards: @discards }
+      (@players + @locations).each { |l| register_loc(l) }
+    end
 
-    # @!attribute [rw] players
-    #   @return [Array<Object>] all players at this table
-    attribute :players, Array, default: []
+    # @return Array all locations that cards can be dealt to
+    def locs
+      @hands.keys
+    end
 
-    # locations as key for array of cards
-    def layout
-      @layout ||= init_layout
+    # @param [String,Symbol] loc which location to see
+    # @return Array[Card] cards for that loc
+    def cards_for(loc)
+      @hands[loc]
     end
 
-    # deal move +count+ card(s) +from+ the top of one @layout location +to+ top of another
-    def move_card(count = 1, from: :shoe, to:)
-      layout[to].unshift(*(layout[from].shift(count)))
+
+    def deal(count = 1, from: :shoe, to:)
+      cards_for(to).push(*cards_for(from).pop(count))
     end
 
-    # return all cards at +loc+ in layout
-    def at(loc)
-      layout[loc]
+    def deal_each_player(count)
+      count.times { @players.each { |p| deal(to: p) } }
     end
 
-    private
-    def init_layout
-      l        = Hash.new { |h, k| h[k] = [] }
-      l[:shoe] = self.deck.shuffle
-      return l
+    def deal_each_location(count)
+      count.times { @locations.each { |p| deal(to: p) } }
     end
 
+    def deal_stage(stage_name)
+      @stages[stage_name].call(self)
+    end
+
+    private
+    def register_loc(loc)
+      @hands[loc] = []
+    end
   end
 end

data/spec/card_nine/dealers/simple_spec.rb

@@ -0,0 +1,20 @@
+require 'rspec'
+require 'card_nine/dealers/simple'
+
+describe CardNine::Dealers::Simple do
+  let(:card_names) { %w{Batman Nightwing Batgirl Robin} }
+  let(:cards) { card_names.map { |c| CardNine::Cards::SimpleCard.new(c) } }
+  let(:deck) { CardNine::Deck.new(cards: card_names) }
+
+  let(:players) { %w{Tim Dick Jason} }
+  let(:locations) { [:batcave] }
+  let(:expected_attributes) {
+    {
+        deck:      deck,
+        locations: locations
+    }
+  }
+  subject { CardNine::Dealers::Simple.new(deck, locations) }
+
+
+end

data/spec/card_nine/dealers/texas_holdem_spec.rb

@@ -2,88 +2,5 @@ require 'rspec'
 require 'card_nine/dealers/texas_holdem'
 
 describe CardNine::Dealers::TexasHoldem do
-  let(:players) { %w|Barbera Stephanie Cassandra| }
-
-  subject { described_class.new(players: players) }
-
-  it { is_expected.to be_a described_class }
-  it { is_expected.to respond_to :new_hand }
-
-  describe '.new_hand' do
-    subject { described_class.new(players: players).new_hand }
-    it { is_expected.to be_a CardNine::Hand }
-  end
-
-  describe 'STAGES' do
-    context ':hole_cards' do
-      subject do
-        h = described_class.new(players: players).new_hand
-        h.deal_stage(:deal_hole_cards)
-        h
-      end
-      it { is_expected.to be_a CardNine::Hand }
-      it { expect(subject.at('Barbera').length).to eq 2 }
-      it { expect(subject.at('Stephanie').length).to eq 2 }
-      it { expect(subject.at('Cassandra').length).to eq 2 }
-      it { expect(subject.at(:discards)).to be_empty }
-      it { expect(subject.at(:shoe).length).to eq 46 }
-    end
-
-    context ':flop' do
-      subject do
-        h = described_class.new(players: players).new_hand
-        h.deal_stage(:flop)
-        h
-      end
-      it { is_expected.to be_a CardNine::Hand }
-      it { expect(subject.at(:community).length).to eq 3 }
-      it { expect(subject.at(:discards).length).to eq 1 }
-      it { expect(subject.at(:shoe).length).to eq 48 }
-    end
-
-    context ':turn' do
-      subject do
-        h = described_class.new(players: players).new_hand
-        h.deal_stage(:turn)
-        h
-      end
-      it { is_expected.to be_a CardNine::Hand }
-      it { expect(subject.at(:community).length).to eq 1 }
-      it { expect(subject.at(:discards).length).to eq 1 }
-      it { expect(subject.at(:shoe).length).to eq 50 }
-    end
-
-    context ':river' do
-      subject do
-        h = described_class.new(players: players).new_hand
-        h.deal_stage(:river)
-        h
-      end
-      it { is_expected.to be_a CardNine::Hand }
-      it { expect(subject.at(:community).length).to eq 1 }
-      it { expect(subject.at(:discards).length).to eq 1 }
-      it { expect(subject.at(:shoe).length).to eq 50 }
-    end
-
-    context 'all in order' do
-      subject do
-        h = described_class.new(players: players).new_hand
-        h.deal_stage(:deal_hole_cards)
-        h.deal_stage(:flop)
-        h.deal_stage(:turn)
-        h.deal_stage(:river)
-        h
-      end
-      it { is_expected.to be_a CardNine::Hand }
-      it { expect(subject.at('Barbera').length).to eq 2 }
-      it { expect(subject.at('Stephanie').length).to eq 2 }
-      it { expect(subject.at('Cassandra').length).to eq 2 }
-      it { expect(subject.at(:community).length).to eq 5 }
-      it { expect(subject.at(:discards).length).to eq 3 }
-      it { expect(subject.at(:shoe).length).to eq 38 }
-
-
-    end
-  end
 
 end

data/spec/card_nine/deck_spec.rb

@@ -7,13 +7,14 @@ describe CardNine::Deck do
   let(:rng) { Random.new }
   subject { described_class.new(cards: cards) }
   it { is_expected.to have_attributes(cards: cards) }
+  it { expect(subject.cards.length).to eq 4 }
   it { expect(subject.rng).to respond_to :rand }
   it { is_expected.to respond_to :shuffle }
   it 'should call shuffle on cards list' do
     cards = %w|Batman Batgirl Robin Nightwing|.map { |n| CardNine::Cards::SimpleCard.new(name: n) }
     rng   = Random.new(1234)
     deck  = described_class.new(rng: rng, cards: cards)
-    expect(deck.cards).to receive(:shuffle)
+    expect(deck.cards).to receive(:shuffle!)
     deck.shuffle
   end
 

data/spec/card_nine/table_spec.rb

@@ -2,73 +2,78 @@ require 'rspec'
 require 'card_nine/table'
 
 describe CardNine::Table do
-  let(:cards) do
-    %w|Batman Batgirl Robin Nightwing|.
-        map { |n| CardNine::Cards::SimpleCard.new(name: n) }
-  end
-  let(:deck) { CardNine::Deck.new(cards: cards) }
-  subject { described_class.new(deck: deck) }
-  it { is_expected.to be_a described_class }
-  it { expect(subject.deck).to eq deck }
-  it { expect(subject.players).to eq [] }
-  it { expect(subject.layout).to be_a Hash }
-  it { expect(subject.layout[:shoe].length).to eq 4 }
-  it { expect(subject.layout[:discards]).to eq [] }
-  describe '.move_card(from: old_pile, to: new_pile)' do
-    context 'using default count and :from' do
-      subject do
-        table = described_class.new(deck: deck, players: %w|Jason Tim|)
-        table.move_card(to: 'Tim')
-        table.move_card(to: 'Jason')
-        table.move_card(to: :discards)
-        table
-      end
+  let(:card_names) { %w{Batman Nightwing Batgirl Robin} }
+  let(:cards) { card_names.map { |c| CardNine::Cards::SimpleCard.new(c) } }
+  let(:shoe) { CardNine::Deck.new(cards: card_names).cards }
 
-      it { is_expected.to be_a CardNine::Table }
+  let(:players) { %w{Tim Dick Jason} }
+  let(:locations) { [:batcave] }
+  let(:expected_locs) { [:shoe, :discards] + locations + players }
+  let(:expected_attributes) {
+    {
+        shoe:      shoe,
+        players:   players,
+        locations: locations,
+        stages:    {}
+    }
+  }
+  subject { CardNine::Table.new(shoe, players, locations) }
 
-      it 'moves each card to the right spot' do
-        expect(subject.at('Tim').length).to eq 1
-        expect(subject.at('Jason').length).to eq 1
-        expect(subject.at(:shoe).length).to eq 1
-        expect(subject.at(:discards).length).to eq 1
-
-      end
+  it { is_expected.to be_a CardNine::Table }
+  it { is_expected.to have_attributes expected_attributes }
+  it { expect(subject.locs).to include *expected_locs }
+  it { expect(subject.discards).to eq [] }
+  it { expect(subject.cards_for(:batcave)).to eq [] }
+  it { expect(subject.cards_for('Tim')).to eq [] }
 
+  describe '.deal(count = 1, to:)' do
+    let(:table) { CardNine::Table.new(shoe, players, locations) }
+    subject { table.deal(to: :batcave); table }
+    it { expect(subject.cards_for(:batcave)).to eq ['Robin'] }
+    it { expect(subject.shoe).to eq %w{Batman Nightwing Batgirl } }
+    context 'with a count of 2' do
+      subject { table.deal(2, to: :batcave); table }
+      it { expect(subject.cards_for(:batcave)).to eq ['Batgirl', 'Robin'] }
+      it { expect(subject.shoe).to eq ['Batman', 'Nightwing'] }
     end
-    context 'with count' do
+    context 'with a from location' do
       subject do
-        table = described_class.new(deck: deck, players: %w|Jason Tim|)
-        table.move_card(2, to: 'Tim')
-        table.move_card(2, to: 'Jason')
+        table.deal(2, to: :batcave)
+        table.deal(from: :batcave, to: 'Tim')
         table
       end
+      it { expect(subject.cards_for(:batcave)).to eq ['Batgirl'] }
+      it { expect(subject.cards_for('Tim')).to eq ['Robin'] }
+    end
+  end
 
-      it { is_expected.to be_a CardNine::Table }
-
-      it 'moves each card to the right spot' do
-        expect(subject.at('Tim').length).to eq 2
-        expect(subject.at('Jason').length).to eq 2
-        expect(subject.at(:shoe).length).to eq 0
-        expect(subject.at(:discards).length).to eq 0
-      end
+  describe '.deal_each_player(grp, count)' do
+    let(:table) { CardNine::Table.new(shoe, players, locations) }
+    subject do
+      table.deal_each_player(1)
+      table
     end
-    context 'with count' do
-      subject do
-        table = described_class.new(deck: deck, players: %w|Jason Tim|)
-        table.move_card(4, to: 'Tim')
-        table.move_card(2, to: 'Jason', from: 'Tim')
-        table
-      end
+    it { expect(subject.shoe).to eq ['Batman'] }
+    it { expect(subject.cards_for('Tim')).to eq ['Robin'] }
 
-      it { is_expected.to be_a CardNine::Table }
+    context 'with a count over 1' do
+      let(:card_names) { %w{Batman Nightwing Batgirl Robin Spoiler Huntress} }
+      subject { table.deal_each_player(2); table }
+      it { expect(subject.shoe).to eq [] }
+      it { expect(subject.cards_for('Dick')).to eq ['Spoiler', 'Nightwing'] }
+    end
+  end
 
-      it 'moves each card to the right spot' do
-        expect(subject.at('Tim').length).to eq 2
-        expect(subject.at('Jason').length).to eq 2
-        expect(subject.at(:shoe).length).to eq 0
-        expect(subject.at(:discards).length).to eq 0
-      end
+  describe '.deal_stage(stage_name)' do
+    it 'should yield to the named proc' do
+      canary = double('canary')
+      expect(canary).to receive(:call)
+      stages = { deal_1: canary }
+      table  = CardNine::Table.new(shoe, players, locations, stages)
+      table.deal_stage(:deal_1)
     end
 
   end
+
+
 end

data/spec/card_nine_spec.rb

@@ -1,10 +1,21 @@
 require 'rspec'
 require 'card_nine'
-
+require 'card_nine/dealers/texas_holdem'
+require 'card_nine/dealers/simple'
 describe CardNine do
 
-  subject { described_class.constants }
-  it { is_expected.to include :Card, :Deck, :Dealer, :Hand }
+  describe 'texas holdem dealer' do
+
+  end
+
+  describe 'Simple dealer' do
+    let(:deck) { CardNine::Deck.new(cards: %w{Batman Nightwing Batgirl Robin}) }
+
+    let(:players) { %w{Tim Dick Jason} }
+    subject { CardNine::Dealers::Simple.new(deck, [:batcave]) }
+
+    it { is_expected.to be_a CardNine::Dealers::Simple }
+  end
 
 
 end

data/spec/spec_helper.rb

@@ -17,7 +17,7 @@ RSpec.configure do |config|
   config.filter_run :focus
   config.run_all_when_everything_filtered = true
   config.filter_run_excluding :rewrite => true
-
+  config.order = :random
   # rspec-mocks config goes here. You can use an alternate test double
   # library (such as bogus or mocha) by changing the `mock_with` option here.
   config.mock_with :rspec do |mocks|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: card_nine
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Scott M Parrish
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-08 00:00:00.000000000 Z
+date: 2014-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -201,17 +201,17 @@ files:
 - lib/card_nine/cards/playing_card.rb
 - lib/card_nine/cards/simple_card.rb
 - lib/card_nine/dealer.rb
+- lib/card_nine/dealers/simple.rb
 - lib/card_nine/dealers/texas_holdem.rb
 - lib/card_nine/deck.rb
-- lib/card_nine/hand.rb
 - lib/card_nine/table.rb
 - spec/card_nine/card_spec.rb
 - spec/card_nine/cards/playing_card_spec.rb
 - spec/card_nine/cards/simple_card_spec.rb
 - spec/card_nine/dealer_spec.rb
+- spec/card_nine/dealers/simple_spec.rb
 - spec/card_nine/dealers/texas_holdem_spec.rb
 - spec/card_nine/deck_spec.rb
-- spec/card_nine/hand_spec.rb
 - spec/card_nine/table_spec.rb
 - spec/card_nine_spec.rb
 - spec/spec_helper.rb
@@ -244,9 +244,9 @@ test_files:
 - spec/card_nine/cards/playing_card_spec.rb
 - spec/card_nine/cards/simple_card_spec.rb
 - spec/card_nine/dealer_spec.rb
+- spec/card_nine/dealers/simple_spec.rb
 - spec/card_nine/dealers/texas_holdem_spec.rb
 - spec/card_nine/deck_spec.rb
-- spec/card_nine/hand_spec.rb
 - spec/card_nine/table_spec.rb
 - spec/card_nine_spec.rb
 - spec/spec_helper.rb

data/lib/card_nine/hand.rb

@@ -1,63 +0,0 @@
-require 'virtus'
-require 'card_nine/deck'
-require 'card_nine/table'
-module CardNine
-  class Hand
-    include Virtus.model
-
-    # @!attribute [rw] deck
-    #   @return [CardNine::Deck]
-    attribute :deck, CardNine::Deck
-
-    # @!attribute [rw] players
-    #   @return [Array]
-    attribute :players, Array, default: []
-
-    # @!attribute [rw] table
-    #   @return [CardNine::Table]
-    attribute :table, CardNine::Table, default: :initialize_table
-
-    attribute :stages, Hash, default: {}
-
-    # create a new hand, yield to a setup block if given
-    def self.start(args = nil)
-      hand = self.new(args)
-      yield hand if block_given?
-      hand
-    end
-
-    # pass deal commands to table
-    # @yieldparam [Table] table for current hand
-    def deal(count = 1, from: :shoe, to:)
-      table.move_card(count, from: from, to: to)
-    end
-
-    def deal_players(count = 1, from: :shoe)
-      count.times do
-        players.each do |p|
-          deal(1, from: from, to: p)
-        end
-      end
-    end
-
-    def discard(count = 1, from: :shoe)
-      deal(count, from: from, to: :discards)
-    end
-
-    def deal_stage(stage_name = nil, &blk)
-      stages[stage_name].call(self) if stage_name && stages[stage_name]
-      blk.call(self) if blk
-      self
-    end
-
-    # @return Array<Card> cards at +loc+ location on table
-    def at(loc)
-      table.at(loc)
-    end
-
-    private
-    def initialize_table
-      CardNine::Table.new(players: players, deck: deck)
-    end
-  end
-end

data/spec/card_nine/hand_spec.rb

@@ -1,68 +0,0 @@
-require 'rspec'
-require 'card_nine/hand'
-
-describe CardNine::Hand do
-  let(:players) { %w|Batman Batgirl Robin| }
-  let(:deck) { CardNine::Cards::PlayingCard.deck }
-  let(:table) { CardNine::Table.new(players: players, deck: deck) }
-  let(:stages) { { deal_five: ->(h) { h.deal_players(5) } } }
-  let(:args) { { players: players, deck: deck } }
-  subject { described_class.new(args) }
-  it { is_expected.to be_a described_class }
-
-  it { expect(subject.deck).to eq deck }
-  it { expect(subject.players).to eq players }
-  it { expect(subject.table).to be_a CardNine::Table }
-  it { expect(subject.stages).to be_a Hash }
-
-  describe '#start(args = nil, &blk)' do
-    it { expect(described_class.start(args)).to be_a described_class }
-    it 'executes block with hand as argument' do
-      hand = described_class.start(args) { |h| h.players << 'Nightwing' }
-      expect(hand.players).to include 'Nightwing'
-    end
-  end
-
-  describe '.at(loc)' do
-    subject { described_class.start(args) }
-    it { is_expected.to be_a described_class }
-    it { expect(subject.at(:shoe).length).to eq 52 }
-    it { expect(subject.at(:discards)).to eq [] }
-  end
-
-  describe '.deal_stage(stage_name = nil, &blk)' do
-    context 'with only block' do
-      subject do
-        h = described_class.start(players: players, deck: deck, table: table, stages: stages)
-        h.deal_stage do |h|
-          h.deal(3, to: :discards)
-        end
-        h
-      end
-      it { expect(subject.at(:discards).length).to eq 3 }
-    end
-
-    context 'with only stage' do
-      subject do
-        h = described_class.start(players: players, deck: deck, table: table, stages: stages)
-        h.deal_stage(:deal_five)
-        h
-      end
-      it { expect(subject.at('Batman').length).to eq 5 }
-      it { expect(subject.at('Batgirl').length).to eq 5 }
-      it { expect(subject.at('Robin').length).to eq 5 }
-    end
-    context 'with both stages and block' do
-      subject do
-        h = described_class.start(players: players, deck: deck, table: table, stages: stages)
-        h.deal_stage(:deal_five) { |h| h.deal(6, to: :discards) }
-        h
-      end
-      it { expect(subject.at('Batman').length).to eq 5 }
-      it { expect(subject.at('Batgirl').length).to eq 5 }
-      it { expect(subject.at('Robin').length).to eq 5 }
-      it { expect(subject.at(:discards).length).to eq 6 }
-      it { expect(subject.at(:shoe).length).to eq 31 }
-    end
-  end
-end