card_nine 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e44ebfb47bb898a6da17933023b5c828c79bef8
-  data.tar.gz: 4510d3a7a56a91e9089044d81f01f9f4996d5a9c
+  metadata.gz: d801904950c45689dbe83317c5fcd4f025f36b9e
+  data.tar.gz: 9395b4a5fa1bc8672e94194846a2d03c30f4bc0e
 SHA512:
-  metadata.gz: a7c30fd41bee2615f58b4c3d11c1504ca73d91e7367228e0137632ebb8d8941a875786132f18fb0498fd8f44f92ab0a9a5b42e97168a2b0012e2c897f976825e
-  data.tar.gz: 00915ec32bfe7681c953d7dfaf2789acb403bf6315efc02d8ae4b2b40b6d1fc6909671fe0628112f00a3280728809a26f663ce9ebc670e09aebab3d285337d89
+  metadata.gz: 76354cab073b3b811ce4670ce2f4ac490e03977ee1b13fd54495c6bae822585c8322f80ecc4a30bed323846edaea9a03e5d147662146b233e138002dac998d51
+  data.tar.gz: abf13a96403a2a7649d0dc10afd73f298ff8c5ac3883cf20dff4668de4f54322181899c7611e68d3a87e336cf7f87f3d8163ced64574c236927f2a253eaa3843

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.6.0

data/lib/card_nine/cards/playing_card.rb

@@ -3,6 +3,7 @@ require 'card_nine/deck'
 
 module CardNine
   module Cards
+    # A class that represents the typical playing card from a 52 card deck.
     class PlayingCard
       # @note implements comparable
       include Comparable

data/lib/card_nine/cards/simple_card.rb

@@ -1,3 +1,4 @@
+require 'card_nine/card'
 module CardNine
   module Cards
     # The simplest card possible.  A Nothing added class with Card included

data/lib/card_nine/dealer.rb

@@ -1,17 +1,29 @@
 module CardNine
   class Dealer
 
+    # @!attribute [rw] deck
+    #   @return [CardNine::Deck]
+    # @!attribute [rw] locations
+    #   @return [Array<Symbol>]
+    # @!attribute [rw] players
+    #   @return [Hash<Symbol => Proc>]
     attr_reader :deck, :locations, :stages
 
+    # @param [CardNine::Deck] deck
+    # @param [Array<Symbol>] locations
+    # @param [stages]
     def initialize(deck, locations, stages = {})
       @deck      = deck
       @locations = locations
       @stages    = stages
     end
 
+    # Create a CardNine::Table
+    # @param [Array<String,Object>] players
+    # @return [CardNine::Table] using deck, players, locations and stages
     def deal(players)
-      CardNine::Table.new(deck.shuffle, players, locations, stages)
+      locs = (locations + players).reduce({}) { |h, e| h[e] = []; h }
+      CardNine::Table.new(deck.shuffle, locs, stages)
     end
-
   end
 end

data/lib/card_nine/dealers/simple.rb

@@ -4,8 +4,6 @@ require 'card_nine/dealer'
 module CardNine
   module Dealers
     class Simple < CardNine::Dealer
-
-
     end
   end
 end

data/lib/card_nine/dealers/texas_holdem.rb

@@ -23,6 +23,8 @@ module CardNine
     # wager(:resolve, hand)
     class TexasHoldem < CardNine::Dealer
 
+      # A hash of stages
+      # @return [Hash<Symbol => Proc>]
       STAGES = {
           deal_hole_cards: ->(t) { t.deal_players(2) },
           flop:            ->(t) { t.discard; t.deal(3, to: :community) },
@@ -31,11 +33,10 @@ module CardNine
           fold:            ->(t, p) { t.remove_player(p) }
       }
 
+      # create a new dealer using a PlayingCard Deck
       def initialize
         super CardNine::Cards::PlayingCard.deck, [:community], STAGES
       end
-
     end
-
   end
 end

data/lib/card_nine/deck.rb

@@ -3,6 +3,8 @@ module CardNine
   class Deck
     include Virtus.model
 
+    # @!attribute [rw] cards
+    #   @return [Array<CardNine::Card>]
     attribute :cards, Array, default: []
 
     # @!attribute [rw] rng

data/lib/card_nine/table.rb

@@ -1,48 +1,42 @@
 module CardNine
   class Table
-    attr_reader :shoe, :players, :hands, :locations, :discards, :stages
+    attr :shoe, :discards, :stages
 
-    def initialize(shoe, players, locations, stages = {})
-      @shoe      = shoe
-      @players   = players
+    def initialize(shoe, locations, stages: {})
+      @shoe     = shoe
+      @discards = []
       @locations = locations
-      @discards  = []
-      @stages    = stages
-      @hands     = { shoe: @shoe, discards: @discards }
-      (@players + @locations).each { |l| register_loc(l) }
+      @stages   = stages
+      register_location(:shoe, shoe)
+      register_location(:discards, @discards)
     end
 
-    # @return Array all locations that cards can be dealt to
-    def locs
-      @hands.keys
+    def register_location(loc_name, loc_container)
+      @locations[loc_name] = loc_container
+    end
+
+    def locations
+      @locations.keys
     end
 
     # @param [String,Symbol] loc which location to see
     # @return Array[Card] cards for that loc
     def cards_for(loc)
-      @hands[loc]
+      @locations[loc]
     end
 
-
     def deal(count = 1, from: :shoe, to:)
       cards_for(to).push(*cards_for(from).pop(count))
     end
 
-    def deal_each_player(count)
-      count.times { @players.each { |p| deal(to: p) } }
+    def deal_each_matching(count = 1, &blk)
+      count.times { match_locations(&blk).each { |p| deal(to: p) } }
     end
 
-    def deal_each_location(count)
-      count.times { @locations.each { |p| deal(to: p) } }
+    def match_locations(&blk)
+      locations.select { |e| blk.call(e, cards_for(e)) }
     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

@@ -3,18 +3,17 @@ 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) {
+  let(:locations) { { batcave: [] } }
+  let(:expected_attributes) do
     {
         deck:      deck,
         locations: locations
     }
-  }
+  end
   subject { CardNine::Dealers::Simple.new(deck, locations) }
-
-
+  it { is_expected.to be_a described_class }
+  it { is_expected.to be_a_kind_of CardNine::Dealer }
 end

data/spec/card_nine/table_spec.rb

@@ -2,78 +2,81 @@ require 'rspec'
 require 'card_nine/table'
 
 describe CardNine::Table do
-  let(:card_names) { %w{Batman Nightwing Batgirl Robin} }
-  let(:cards) { card_names.map { |c| CardNine::Cards::SimpleCard.new(c) } }
+  let(:card_names) { %w{Zorro Batman Batgirl Robin} }
   let(:shoe) { CardNine::Deck.new(cards: card_names).cards }
+  let(:locations) do
+    h            = {}
+    h[:batplane] = []
+    h
+  end
+  subject { described_class.new(shoe, locations) }
 
-  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 { 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 [] }
+  it { is_expected.to be_a described_class }
+  it { expect(subject.locations).to eq [:batplane, :shoe, :discards] }
 
-  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'] }
+  describe 'easy stuff' do
+    it 'returns the container for a given location' do
+      subject.register_location(:tim, :drake_manor)
+      expect(subject.cards_for(:tim)).to eq :drake_manor
     end
-    context 'with a from location' do
-      subject do
-        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'] }
+    it 'registers locations' do
+      subject.register_location(:tim, [:drake_manor])
+      expect(subject.cards_for(:tim)).to eq [:drake_manor]
+    end
+    it 'reports locations' do
+      subject.register_location(:tim, [:drake_manor])
+      expect(subject.locations).to eq [:batplane, :shoe, :discards, :tim]
     end
   end
 
-  describe '.deal_each_player(grp, count)' do
-    let(:table) { CardNine::Table.new(shoe, players, locations) }
-    subject do
-      table.deal_each_player(1)
-      table
+  describe '.deal(count = 1, from: :shoe, to:' do
+    context 'with default count' do
+      subject do
+        s = described_class.new(shoe, locations)
+        s.deal(to: :batplane)
+        s
+      end
+      it { expect(subject.shoe.count).to eq 3 }
+      it { expect(subject.cards_for(:batplane).first).to eq 'Robin' }
     end
-    it { expect(subject.shoe).to eq ['Batman'] }
-    it { expect(subject.cards_for('Tim')).to eq ['Robin'] }
-
-    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'] }
+    context 'with given count' do
+      subject do
+        s = described_class.new(shoe, locations)
+        s.deal(2, to: :batplane)
+        s
+      end
+      it { expect(subject.shoe.count).to eq 2 }
+      it { expect(subject.cards_for(:batplane).first).to eq 'Batgirl' }
+      it { expect(subject.cards_for(:batplane).last).to eq 'Robin' }
     end
   end
+  describe '.deal_each_matching(count = 1){|location, container|}' do
+    context 'with default count' do
+      subject do
+        locations['Alfred'] = []
+        locations['James']  = []
+        s                   = described_class.new(shoe, locations)
+        s.deal_each_matching { |location, container| location.is_a? String }
+        s
+      end
+      it { expect(subject.shoe.count).to eq 2 }
+      it { expect(subject.cards_for('Alfred').first).to eq 'Robin' }
+      it { expect(subject.cards_for('James').first).to eq 'Batgirl' }
+      it { expect(subject.discards).to eq [] }
+      it { expect(subject.cards_for(:batplane)).to eq [] }
 
-  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
-
+    context 'with given count' do
+      subject do
+        s = described_class.new(shoe, locations)
+        s.deal_each_matching(2) { |l, c| l.is_a?(Symbol) && l != :shoe }
+        s
+      end
+      it { expect(subject.shoe.count).to eq 0 }
+      it { expect(subject.cards_for(:discards)).to eq ['Batgirl', 'Zorro'] }
+      it { expect(subject.cards_for(:batplane)).to eq ['Robin', 'Batman'] }
+    end
   end
+end
 
 
-end

data/spec/card_nine_spec.rb

@@ -5,17 +5,14 @@ require 'card_nine/dealers/simple'
 describe CardNine do
 
   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]) }
+    subject { CardNine::Dealers::Simple.new(deck, { batcave: [] }) }
 
     it { is_expected.to be_a CardNine::Dealers::Simple }
   end
-
-
 end

data/spec/spec_helper.rb

@@ -16,7 +16,7 @@ RSpec.configure do |config|
 
   config.filter_run :focus
   config.run_all_when_everything_filtered = true
-  config.filter_run_excluding :rewrite => 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.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: card_nine
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Scott M Parrish
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-20 00:00:00.000000000 Z
+date: 2014-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -235,7 +235,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Game Dev Toolbox. Cards