cardlike 0.0.1

data/lib/cardlike/score.rb

@@ -0,0 +1,47 @@
+module Cardlike
+  # 
+  # Increment the score for a target (usually a string or symbol).
+  #
+  #   Cardlike.score "player 1" # => sets the score to 1
+  #
+  def self.score(target)
+    @scores ||= {}
+    @scores[target] ||= 0
+    @scores[target] += 1
+  end
+
+  # 
+  # Clear all scores.
+  #
+  def self.clear_scores
+    @scores = {}
+  end
+
+  # 
+  # Return the hash of the form <tt>{target: score}</tt>.
+  #
+  def self.scores
+    @scores ||= {}
+    @scores
+  end
+
+  # 
+  # Retrieve the score for a target (usually a string or symbol).
+  #
+  #   Cardlike.score "player 1" # => sets the score to 1
+  #   Cardlike.score "player 1" # => sets the score to 2
+  #   Cardlike.the_score "player 1" # => 2
+  #
+  def self.the_score(target)
+    @scores ||= {}
+    @scores[target]
+  end
+
+  # 
+  # Set the score for a target to a particular value.
+  #
+  def self.set_score(target, value)
+    @scores ||= {}
+    @scores[target] = value
+  end
+end

data/lib/cardlike/turn.rb

@@ -0,0 +1,27 @@
+module Cardlike
+  # 
+  # Define a turn block that can be run with Cardlike.begin_new_turn.
+  #
+  #   Cardlike.define_turn do |current_player|
+  #     puts "#{current_player}'s turn"
+  #   end
+  #
+  def self.define_turn(&block)
+    @turn = block
+  end
+
+  #
+  # Return the turn block set by Cardlike.define_turn.
+  #
+  def self.the_turn
+    @turn
+  end
+
+  #
+  # Call the block defined by Cardlike.define_turn. You can pass arguments to
+  # the block as well.
+  #
+  def self.begin_new_turn(*args)
+    @turn.call(*args)
+  end
+end

data/lib/cardlike/version.rb

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

data/lib/cardlike.rb

@@ -0,0 +1,154 @@
+require "cardlike/version"
+require "cardlike/deck"
+require "cardlike/card"
+require "cardlike/hand"
+require "cardlike/score"
+require "cardlike/turn"
+require "active_support/inflector"
+
+module Cardlike
+  def self.version
+    "#{self} version #{VERSION}"
+  end
+
+  #
+  # Optionally use this to wrap Cardlike DSL methods to avoid having to prefix
+  # them with +Cardlike+. This is  mainly useful for large blocks.
+  #
+  #   Cardlike.game do
+  #     type_of_card :playing_card { has :suit }
+  #   end
+  #
+  # is the same as
+  #
+  #   Cardlike.type_of_card :playing_card { has :suit }
+  #
+  def self.game(&block)
+    self.class_eval(&block)
+  end
+
+  #
+  # Set up a new Deck with the given name. Returns the created Deck which can
+  # also be accessed with +the_deck+. Within the block you may use the Deck DSL.
+  #
+  #   Cardlike.deck "Poker Deck" do
+  #     include_card "King of Diamonds"
+  #     include_card "Three of Clubs"
+  #   end
+  #
+  def self.deck(name, &block)
+    @decks ||= {}
+    d = Deck.new(name: name)
+    d.instance_eval(&block) if block_given?
+    @decks[name] = d
+    d
+  end
+
+  #
+  # Set up a new Hand with the given name. Returns the created Hand which can
+  # also be accessed with +the_deck+. Within the block you may use the Hand DSL.
+  #
+  #   Cardlike.hand "Poker Hand" do
+  #     include_card "King of Diamonds"
+  #     include_card "Three of Clubs"
+  #   end
+  #
+  def self.hand(name, &block)
+    @hands ||= {}
+    d = Hand.new(name: name)
+    d.instance_eval(&block) if block_given?
+    @hands[name] = d
+    d
+  end
+
+  #
+  # Return a Deck created by the +deck+ method by +name+.
+  #
+  #   Cardlike.the_deck("Blackjack Deck").size # => 52
+  #
+  def self.the_deck(name)
+    @decks ||= {}
+    @decks[name]
+  end
+
+  #
+  # Return a Hand created by the +hand+ method by +name+.
+  #
+  #   Cardlike.the_hand("Poker Hand").size # => 5
+  #
+  def self.the_hand(name)
+    @hands ||= {}
+    @hands[name]
+  end
+
+  # 
+  # Return a Card created by the +card+ method. Also will return cards created
+  # by the custom +new_+ card methods (see +type_of_card+).
+  #
+  #   Cardlike.the_card("Six of Diamonds").name # => "Six of Diamonds"
+  #
+  def self.the_card(name)
+    @cards ||= {}
+    @cards[name]
+  end
+
+  #
+  # Create a new Card with the given name and block evaluated in the context of
+  # the Card. Returns the Card (that can also be accessed with +the_card+). You
+  # may use the Card DSL in the block.
+  #
+  #   Cardlike.card "Fire Monster" do
+  #     text "A red-hot monster."
+  #   end
+  #
+  def self.card(name, &block)
+    c = Card.create(name, &block)
+    @cards ||= {}
+    @cards[name] = c
+    c
+  end
+
+  #
+  # Create a new subclass of Card with its own properties as defined in the
+  # block. You may use the Card class DSL in the block. Automatically defines a
+  # method for creating new objects of that class, prefixed by +new_+. For
+  # example, a <tt>type_of_card :fun_card</tt> defines the method +new_fun_card+
+  # (which operates like the +card+ method) that can be used in either a +deck+
+  # block or directly.
+  #   
+  #   Cardlike.type_of_card :playing_card do
+  #     has :value
+  #     has :suit
+  #   end
+  #
+  # You can then access the card with:
+  #
+  #   Cardlike.new_playing_card "Six of Spades" do
+  #     value 6
+  #     suit 'spades'
+  #   end
+  #
+  # or:
+  #
+  #   Cardlike.deck "Poker Deck" do
+  #     new_playing_card "Six of Spades" do
+  #       value 6
+  #       suit 'spades'
+  #     end
+  #   end
+  #
+  def self.type_of_card(name, &block)
+    klass = Class.new(Card)
+    klass_name = name.to_s.camelize
+    name_underscored = name.to_s.downcase.underscore
+    Object.const_set(klass_name, klass) if not Object.const_defined?(klass_name)
+    c = Object.const_get(klass_name)
+    c.class_eval(&block) if block_given?
+
+    Deck.send(:define_method, "new_#{name_underscored}", lambda { |arg, &blk| card = c.create(arg, &blk); self << card; card })
+    self.class.send(:define_method, "new_#{name_underscored}", lambda { |arg, &blk| card = c.create(arg, &blk); @cards ||= {}; @cards[arg] = card; card })
+
+    c
+  end
+
+end

data/spec/integration/card_construction_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe 'Defining a card' do
+  context "using the basic card DSL" do
+
+    context "for a basic card" do
+      before do
+        @card = Cardlike.card "Fire Monster" do
+          text "A red-hot monster."
+        end
+      end
+
+      it "creates a Card object" do
+        @card.should be_a_kind_of Cardlike::Card
+      end
+
+      it "properly sets the card name" do
+        @card.name.should eq "Fire Monster"
+      end
+
+      it "properly sets the card text" do
+        @card.text.should eq "A red-hot monster."
+      end
+    end
+
+  end
+
+  context "using the custom card DSL" do
+    before do
+      @playing_card = Cardlike.type_of_card :playing_card do
+        has :value
+        has :suit
+      end
+    end
+
+    it "creates a new Class" do
+      @playing_card.should be_a_kind_of Class
+    end
+
+    it "creates a subclass of Card" do
+      @playing_card.should < Cardlike::Card
+    end
+
+    it "creates a dynamic custom Class" do
+      @playing_card.name.should eq "PlayingCard"
+    end
+
+    it "creates an accessor for the custom field" do
+      @playing_card.new.should respond_to :suit
+    end
+
+    context "when instantiated with the 'new_' factory" do
+      before do
+        deck = Cardlike.deck "Test" do
+          new_playing_card "Six of Spades" do
+            value 6
+            suit 'Spades'
+          end
+        end
+        @card = deck.first
+      end
+
+      it "creates a custom Card object" do
+        @card.should be_a_kind_of Cardlike::Card
+      end
+
+      it "creates an accessor for the custom field" do
+        @card.should respond_to :suit
+      end
+    end
+    
+    context "when instantiated" do
+      before do
+        @card = @playing_card.create "Six of Spades" do
+          value 6
+          suit 'Spades'
+        end
+      end
+
+      it "creates a custom Card object" do
+        @card.should be_a_kind_of Cardlike::Card
+      end
+
+      it "creates an accessor for the custom field" do
+        @card.should respond_to :suit
+      end
+
+      it "does not affect other Card instances" do
+        @card2 = Cardlike.card "Castle"
+        @card2.should_not respond_to :suit
+      end
+
+      it "sets the field properly" do
+        @card[:suit].should eq 'Spades'
+      end
+
+      it "does not allow fields to be set again" do
+        lambda { @card.suit 'Clubs' }.should raise_error(StandardError)
+      end
+
+    end
+
+  end
+
+end

data/spec/integration/dealing_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'A deck of cards' do
+  before do
+    @cards = []
+    @cards << Cardlike::Card.new(name: 'Leonardo', text: 'Has two swords.')
+    @cards << Cardlike::Card.new(name: 'Donatello', text: 'Has a Bo staff.')
+    @cards << Cardlike::Card.new(name: 'Michaelangelo', text: 'Has Nunchuku.')
+    @cards << Cardlike::Card.new(name: 'Raphael', text: 'Has Sai.')
+
+    @deck = Cardlike::Deck.new(name: 'Turtles', cards: @cards)
+  end
+
+  context 'when a card is drawn' do
+    before do
+      @drawn = @deck.draw
+    end
+
+    it 'is one of the cards from the deck' do
+      @cards.should include @drawn
+    end
+
+    it 'is no longer in the deck' do
+      @deck.should_not include @drawn
+    end
+  end
+
+  context "when a card is drawn into a Hand" do
+    before do
+      @hand = Cardlike::Hand.new(name: 'Player 1')
+      @drawn = @deck.draw_into @hand
+    end
+
+    it "inserts the card into the Hand" do
+      @hand.should include @drawn
+    end
+
+    it "removes the card from the Deck" do
+      @deck.should_not include @drawn
+    end
+  end
+end

data/spec/integration/deck_construction_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe "Building a deck" do
+  context "with a simple card" do
+    before do
+      Cardlike.game do
+        deck "Simple Deck" do
+          card "Boring Card"
+        end
+      end
+    end
+
+    it "has 1 card" do
+      Cardlike.the_deck("Simple Deck").size.should eq 1
+    end
+
+    it "contains the first card" do
+      Cardlike.the_deck("Simple Deck").first.name.should eq "Boring Card"
+    end
+  end
+
+  context "with a bunch of cards defined in the block" do
+    before do
+      Cardlike.game do
+        type_of_card :playing_card do
+          has :value
+          has :suit
+        end
+
+        deck "Poker Deck" do
+          new_playing_card "Ace of Spades" do
+            value 11
+            suit 'Spades'
+          end
+
+          new_playing_card "Ace of Diamonds" do
+            value 11
+            suit 'Diamonds'
+          end
+
+          new_playing_card "Five of Clubs" do
+            value 5
+            suit 'Clubs'
+          end
+        end
+      end
+
+    end
+
+    it "contains the right number of cards" do
+      Cardlike.the_deck("Poker Deck").size.should eq 3
+    end
+
+    it "contains a card created in the block" do
+      Cardlike.the_deck("Poker Deck").first.name.should eq "Ace of Spades"
+    end
+
+    context "and another deck exists" do
+      before do
+        Cardlike.deck "Go Fish Deck" do
+          new_playing_card "Seven of Spades" do
+            value 7
+            suit :spades
+          end
+        end
+      end
+
+      it "the first deck contains the right number of cards" do
+        Cardlike.the_deck("Poker Deck").size.should eq 3
+      end
+
+      it "the new deck contains the right number of cards" do
+        Cardlike.the_deck("Go Fish Deck").size.should eq 1
+      end
+
+    end
+  end
+
+  context "with a bunch of cards pre-defined" do
+    before do
+      Cardlike.type_of_card :playing_card do
+        has :value
+        has :suit
+      end
+
+      Cardlike.new_playing_card "King of Diamonds" do
+        value 10
+        suit :diamonds
+      end
+
+      Cardlike.new_playing_card "Three of Clubs" do
+        value 3
+        suit :clubs
+      end
+
+      Cardlike.deck "Blackjack Deck" do
+        include_card "King of Diamonds"
+        include_card "Three of Clubs"
+      end
+    end
+
+    it "contains the right number of cards" do
+      Cardlike.the_deck("Blackjack Deck").size.should eq 2
+    end
+
+    it "contains a card created in the block" do
+      Cardlike.the_deck("Blackjack Deck").first.name.should eq "King of Diamonds"
+    end
+
+  end
+
+  context "with multiple copies of a card" do
+    before do
+      Cardlike.type_of_card :playing_card do
+        has :value
+        has :suit
+      end
+
+      Cardlike.new_playing_card "Queen of Diamonds" do
+        value 10
+        suit :diamonds
+      end
+
+      Cardlike.deck "Copy Deck" do
+        6.times { copy_card "Queen of Diamonds" }
+      end
+    end
+
+    it "contains the right number of cards" do
+      Cardlike.the_deck("Copy Deck").size.should eq 6
+    end
+
+    it "contains a card created in the block" do
+      Cardlike.the_deck("Copy Deck").first.name.should eq "Queen of Diamonds"
+    end
+
+    it "contains another card created in the block" do
+      Cardlike.the_deck("Copy Deck")[2].name.should eq "Queen of Diamonds"
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'cardlike'
+
+RSpec.configure do |config|
+end

data/spec/units/cardlike_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Cardlike do
+  describe '.version' do
+    it 'returns correct version' do
+      Cardlike.version.should eq "Cardlike version #{Cardlike::VERSION}"
+    end
+  end
+end

data/spec/units/deck_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Cardlike::Deck do
+  let (:deck) { Cardlike::Deck.new(cards: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']) }
+
+  describe "#shuffle" do
+    before do
+      @orig_deck = deck.dup
+      @shuffled = deck.shuffle
+    end
+
+    it "returns a Deck" do
+      @shuffled.should be_a_kind_of Cardlike::Deck
+    end
+
+    it "returns a differently-ordered deck" do
+      @shuffled.should_not eq @orig_deck
+    end
+
+    it "retains the order of the deck" do
+      deck.should eq @orig_deck
+    end
+  end
+
+  describe "#shuffle!" do
+    before do
+      @orig_deck = deck.dup
+      @shuffled = deck.shuffle!
+    end
+
+    it "the deck remains a Deck" do
+      @shuffled.should be_a_kind_of Cardlike::Deck
+    end
+
+    it "returns a differently-ordered deck" do
+      deck.should_not eq @orig_deck
+    end
+
+    it "changes the order of the deck" do
+      deck.should_not eq @orig_deck
+    end
+  end
+end

data/spec/units/hand_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe "A hand of cards" do
+  context "with 4 cards added" do
+    before do
+      Cardlike.hand "Player 1" do
+        card "Boring Card One"
+        card "Boring Card Two"
+        card "Boring Card Three"
+        card "Boring Card Four"
+      end
+    end
+
+    it "has 4 cards" do
+      Cardlike.the_hand("Player 1").size.should eq 4
+    end
+
+    it "contains the first card" do
+      Cardlike.the_hand("Player 1").first.name.should eq "Boring Card One"
+    end
+
+    context "when removing a specific card" do
+      before do
+        @card1 = Cardlike.the_hand("Player 1").remove_card "Boring Card One"
+      end
+
+      it "can remove a specific card" do
+        @card1.name.should eq "Boring Card One"
+      end
+
+      it "removes the card from the Hand" do
+        Cardlike.the_hand("Player 1").size.should eq 3
+      end
+    end
+
+    context "when removing a card with remove_card_if" do
+      before do
+        @card1 = Cardlike.the_hand("Player 1").remove_card_if { |c| c.name =~ /Three/ }.first
+      end
+
+      it "removes and returns the correct card" do
+        @card1.name.should eq "Boring Card Three"
+      end
+
+      it "removes the card from the Hand" do
+        Cardlike.the_hand("Player 1").size.should eq 3
+      end
+    end
+  end
+end

data/spec/units/score_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Cardlike do
+  describe ".score" do
+    context "with a new target" do
+      before do
+        Cardlike.clear_scores
+        Cardlike.score :foobar
+      end
+
+      it "sets a new target with the score" do
+        Cardlike.the_score(:foobar).should eq 1
+      end
+    end
+
+    context "with an existing target" do
+      before do
+        Cardlike.game do
+          3.times { score :foobaz }
+        end
+      end
+
+      it "increments the score for the target" do
+        Cardlike.the_score(:foobaz).should eq 3
+      end
+    end
+  end
+
+  describe ".clear_scores" do
+    before do
+      Cardlike.score :barfoo
+      Cardlike.clear_scores
+    end
+
+    it "removes all scores" do
+      Cardlike.scores.should be_empty
+    end
+  end
+
+  describe ".scores" do
+    before do
+      Cardlike.clear_scores
+      Cardlike.game do
+        2.times { score :foo }
+        3.times { score :bar }
+        1.times { score :baz }
+      end
+    end
+
+    it "returns a hash of target => score" do
+      hash = {:foo => 2, :bar => 3, :baz => 1}
+      Cardlike.scores.should eq hash
+    end
+  end
+
+  describe ".set_score" do
+    before do
+      Cardlike.clear_scores
+      Cardlike.game do
+        score :foo
+        score :foo
+        score :bar
+
+        set_score :foo, 5
+      end
+    end
+
+    it "sets a score to particular value" do
+      Cardlike.the_score(:foo).should eq 5
+    end
+  end
+end
+