ace_of_spades 0.0.1.pre

data/lib/ace_of_spades/suit.rb

@@ -0,0 +1,45 @@
+class AceOfSpades::Suit
+  include Comparable
+  attr_accessor :card
+  
+  def initialize(suit)
+    @symbol = Suit.parse(suit)
+    raise "Invalid argument: #{suit}" unless @symbol
+  end
+
+  def <=>(suit)
+    return nil unless suit.instance_of?(Suit)
+    SUITS.index(@symbol) <=> SUITS.index(suit.to_sym)
+  end
+
+  def to_sym
+    @symbol
+  end
+
+  def to_s
+    @symbol.to_s
+  end
+  alias_method :to_str, :to_s
+
+  def method_missing(method, *args, &block)
+    match = Suit.parse(%r(.+\?\z).match(method).to_s.chop)
+    return super unless match
+    @symbol == match
+  end
+
+  class << self
+    def suitable?(suit)
+      !!parse(suit)
+    end
+    
+    def wrap(suit)
+      return suit if suit.instance_of?(Suit)
+      new(suit) if suitable?(suit)
+    end
+
+    def parse(arg)
+      regex = arg.to_s.length == 1 ? %r(\A#{arg})i : %r(\A#{arg}(s*)\z)i
+      SUITS.grep(regex).first
+    end
+  end
+end

data/lib/ace_of_spades/value.rb

@@ -0,0 +1,58 @@
+class AceOfSpades::Value
+  include Comparable
+  attr_accessor :card
+
+  def initialize(value)
+    @symbol = Value.parse(value)
+    raise "Invalid argument: #{value}" unless @symbol
+  end
+
+  def <=>(value)
+    return nil unless value.instance_of?(Value)
+    to_i <=> value.to_i
+  end
+
+  def to_sym
+    @symbol
+  end
+
+  def to_s
+    @symbol.to_s
+  end
+  alias_method :to_str, :to_s
+
+  def to_i
+    aces_high? ? VALUES.rindex(@symbol) + 1 : VALUES.index(@symbol) + 1
+  end#
+  alias_method :to_int, :to_i
+
+  def aces_high?
+    return true unless card
+    card.aces_high?
+  end
+
+  def method_missing(method, *args, &block)
+    match = Value.parse(%r(.+\?\z).match(method).to_s.chop)
+    return super unless match
+    @symbol == match
+  end
+
+  class << self
+    def valuable?(value)
+      !!parse(value)
+    end
+    
+    def wrap(value)
+      return value if value.instance_of?(Value)
+      new(value) if valuable?(value)
+    end
+
+    def parse(arg)
+      return VALUES[arg - 1] if (1..14).include?(arg)
+      short_arg = arg.to_s.length == 1
+      regex  = short_arg ? %r(\A#{arg})i  : %r(\A#{arg}\z)i
+      values = short_arg ? VALUES[-4..-1] : VALUES
+      values.grep(regex).first
+    end
+  end
+end

data/spec/lib/card_spec.rb

@@ -0,0 +1,294 @@
+require "spec_helper"
+
+describe Card do
+  let(:ace_spades) { Card.new(:ace, :spades) }
+  let(:joker) { Card.new(:joker) }
+
+  describe '.new' do
+    context "when called with valid arguments" do
+      let(:ten_hearts) { Card.new(10, 'h') }
+      it "initializes" do
+        expect(ace_spades).to be_an_instance_of(Card)
+        expect(ten_hearts).to be_an_instance_of(Card)
+      end
+      it "correctly saves the suit" do
+        expect(ace_spades.suit.to_sym).to be(:Spades)
+        expect(ten_hearts.suit.to_sym).to be(:Hearts)
+      end
+      it "correctly saves the value" do
+        expect(ace_spades.value.to_sym).to be(:Ace)
+        expect(ten_hearts.value.to_sym).to be(:Ten)
+      end
+      it "saves self as value.card and suit.card" do
+        expect(ace_spades.value.card).to be(ace_spades)
+        expect(ace_spades.suit.card).to be(ace_spades)
+      end
+      context "when a joker" do
+        it "initializes as a joker" do
+          expect(joker.suit).to be_nil
+          expect(joker.value).to be_nil
+        end
+      end
+    end
+    context "when initialized with invalid arguments" do
+      it "raises an error" do
+        expect{Card.new}.to raise_error
+        expect{Card.new(:joker, :foo)}.to raise_error
+        expect{Card.new(:ace, :foo)}.to raise_error
+        expect{Card.new('a', 5)}.to raise_error
+        expect{Card.new(:foo)}.to raise_error
+      end
+    end
+  end
+
+  describe '.wrap' do
+    context "when passed a Card instance" do
+      it "returns the card instance" do
+        expect(Card.wrap(joker)).to be(joker)
+      end
+    end
+    context "when passed arguments that can be converted into a Card instance" do
+      it "returns the arguments as a Card instance" do
+        expect(Card.wrap(:ace, :spades)).to eq(ace_spades)
+      end
+    end
+    context "when passed arguments that cannot me converted into a Card instance" do
+      it "returns nil" do
+        expect(Card.wrap(:foo)).to be_nil
+      end
+    end
+  end
+
+  describe '#value=' do
+    let(:card) { ace_spades }
+    context "when passed a Value instance" do
+      it "assigns the Value" do
+        card.value = Value.new(:king)
+        expect(card.value).to be_an_instance_of(Value)
+        expect(card.value.to_sym).to be(:King)
+      end
+    end
+    context "when passed an object that can be converted to a Value" do
+      it "assigns the Value" do
+        card.value = :king
+        expect(card.value).to be_an_instance_of(Value)
+        expect(card.value.to_sym).to be(:King)
+      end
+    end
+    context "when passed an object that cannot be converted to a Value" do
+      it "assigns nil" do
+        card.value = :foo
+        expect(card.value).to be_nil
+      end
+    end
+  end
+
+  describe '#suit=' do
+    let(:card) { ace_spades }
+    context "when passed a Suit instance" do
+      it "assigns the Suit" do
+        card.suit = Suit.new(:hearts)
+        expect(card.suit).to be_an_instance_of(Suit)
+        expect(card.suit.to_sym).to be(:Hearts)
+      end
+    end
+    context "when passed an object that can be converted to a Suit" do
+      it "assigns the Suit" do
+        card.suit = :hearts
+        expect(card.suit).to be_an_instance_of(Suit)
+        expect(card.suit.to_sym).to be(:Hearts)
+      end
+    end
+    context "when passed an object that cannot be converted to a Suit" do
+      it "assigns nil" do
+        card.suit = :foo
+        expect(card.suit).to be_nil
+      end
+    end
+  end
+
+  describe '#deck & #deck=' do
+    let(:deck) { Deck.new }
+    let(:card) { ace_spades }
+    it "retrieves the deck" do
+      expect(card.deck).to be_nil
+    end
+    it "assigns the deck" do
+      card.deck = deck
+      expect(card.deck).to be(deck)
+    end
+  end
+
+  describe '#aces_high?' do
+    let(:deck) { Deck.new(aces_high: true) }
+    let(:card) { ace_spades }
+    it "returns the #aces_high? result from the deck" do
+      card.deck = deck
+      expect(card.aces_high?).to be(true)
+      deck.aces_high = false
+      expect(card.aces_high?).to be(false)
+    end
+    context "when the card has no deck" do
+      it "returns true" do
+        expect(card.aces_high?).to be(true)
+      end
+    end
+  end
+
+  describe'#<=>' do
+    let(:ace_hearts) { Card.new(14, :H) }
+    let(:king_spades) { Card.new(13, :S) }
+    let(:king_hearts) { Card.new(13, :H) }
+    context "when passed an incomparable object" do
+      it "returns nil" do
+        expect(ace_spades <=> 5).to be_nil
+      end
+    end
+    context "when passed a card with the same value and suit" do
+      let(:ace_of_spades) { Card.new(14, :S) }
+      it "returns 0" do
+        expect(ace_spades <=> ace_of_spades).to be(0)
+      end
+    end
+    context "when passed a card with a higher suit" do
+      it "returns -1" do
+        expect(ace_hearts <=> ace_spades).to be(-1)
+      end
+    end
+    context "when passed a card with a lower suit" do
+      it "returns 1" do
+        expect(ace_spades <=> ace_hearts).to be(1)
+      end
+    end
+    context "when passed a card with a higher suit and a lower value" do
+      it "returns -1" do
+        expect(ace_hearts <=> king_spades).to be(-1)
+      end
+    end
+    context "when passed a card with a lower suit and a higher value" do
+      it "returns 1" do
+        expect(king_spades <=> ace_hearts).to be(1)
+      end
+    end
+    context "when passed a joker" do
+      it "returns nil" do
+        expect(ace_spades <=> joker).to be_nil
+      end
+    end
+    describe Comparable do
+      it "compares correctly" do
+        expect(ace_spades == ace_spades).to be(true)
+        expect(ace_hearts < ace_spades).to be(true)
+        expect(ace_spades > ace_hearts).to be(true)
+      end
+    end
+  end
+  
+  describe '#to_s' do
+    context "when a joker" do
+      it "returns 'Joker'" do
+        expect(joker.to_s).to eq('Joker')
+      end
+    end
+    context "when not a joker" do
+      it "returns 'Value of Suit'" do
+        expect(ace_spades.to_s).to eq('Ace of Spades')
+      end
+    end
+  end
+
+  describe '#to_sym' do
+    context "when a joker" do
+      it "returns :Joker" do
+        expect(joker.to_sym).to eq(:Joker)
+      end
+    end
+    context "when not a joker" do
+      it "returns :'Value of Suit'" do
+        expect(ace_spades.to_sym).to eq(:'Ace of Spades')
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context "when valid" do
+      it "returns true" do
+        expect(ace_spades.valid?).to be(true)
+        expect(joker.valid?).to be(true)
+      end
+    end
+    context "when invalid" do
+      it "returns false" do
+        ace_spades.instance_variable_set(:@value, 'foo')
+        ace_spades.instance_variable_set(:@suit, 'bar')
+        expect(ace_spades.valid?).to be(false)
+      end
+    end
+  end
+  describe '#joker?' do
+    context "when a joker" do
+      it "returns true" do
+        expect(joker.joker?).to be(true)
+      end
+    end
+    context "when not a joker" do
+      it "returns false" do
+        expect(ace_spades.joker?).to be(false)
+      end
+    end
+  end
+
+  describe '#validate!' do
+    context "when valid" do
+      it "returns self" do
+        expect(ace_spades.validate!).to be(ace_spades)
+      end
+    end
+    context "when invalid" do
+      it "raises error" do
+        ace_spades.instance_variable_set(:@value, false)
+        ace_spades.instance_variable_set(:@suit, false)
+        expect{ace_spades.validate!}.to raise_error
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    context "when passed a valid predicate method" do
+      context "when a value" do
+        it "returns true or false" do
+          expect(ace_spades.ace?).to be(true)
+          expect(ace_spades.king?).to be(false)
+          expect(joker.ace?).to be(false)
+        end
+      end
+      context "when a suit" do
+        it "returns true or false" do
+          expect(ace_spades.spade?).to be(true)
+          expect(ace_spades.spades?).to be(true)
+          expect(ace_spades.hearts?).to be(false)
+          expect(joker.spades?).to be(false)
+        end
+      end
+      context "when a value and suit" do
+        it "returns true or false" do
+          expect(ace_spades.ace_spades?).to be(true)
+          expect(ace_spades.ace_of_spades?).to be(true)
+          expect(ace_spades.ace_of_hearts?).to be(false)
+          expect(ace_spades.king_spades?).to be(false)
+        end
+      end
+    end
+    context "when passed an invalid predicate method" do
+      it "raises error" do
+        expect{ace_spades.foo?}.to raise_error(NoMethodError)
+        expect{ace_spades.ace_foo?}.to raise_error(NoMethodError)
+      end
+    end
+    context "when passed an invalid method" do
+      it "raises error" do
+        expect{ace_spades.foo}.to raise_error(NoMethodError)
+      end
+    end
+  end
+end

data/spec/lib/deck_spec.rb

@@ -0,0 +1,291 @@
+require 'spec_helper'
+
+describe Deck do
+  let(:deck) { Deck.new }
+ 
+  describe '.new' do
+    context "when passed valid params" do
+      it "initializes with 52 cards" do
+        expect(deck.length).to be(52)
+      end
+      it "initializes with 4 suits" do
+        expect(deck.group_by{|c|c.suit.to_sym}.count).to be(4)
+      end
+      it "initializes with 13 values" do
+        expect(deck.group_by{|c|c.value.to_sym}.count).to be(13)
+      end
+      it "initializes with 13 values per suit" do
+        values_per_suit = deck.group_by{|c|c.suit.to_sym}[:Spades].group_by{|c|c.value.to_sym}.count
+        expect(values_per_suit).to be(13)
+      end
+      it "initializes as shuffled" do
+        expect(deck[0..12].group_by{|c|c.suit.to_sym}.count).to_not be(1)
+        expect(deck[0..12].group_by{|c|c.value.to_sym}.count).to_not be(13)
+      end
+      it "initializes with aces high" do
+        expect(deck.aces_high?).to be(true)
+      end
+      context "when initialized with (false)" do
+        let(:deck) { Deck.new(false) }
+        it "creates the deck but does not add any cards" do
+          expect(deck.empty?).to be(true)
+        end
+      end
+      context "when initialized with {jokers: true}" do
+        let(:deck) { Deck.new(jokers: true) }
+        it "initializes with 54 cards" do
+          expect(deck.length).to be(54)
+        end
+        it "initializes with 2 jokers" do
+          expect(deck.find_cards(:joker).count).to be(2)
+        end
+      end
+      context "when initialized with {shuffle: false}" do
+        let(:deck) { Deck.new(shuffle: false) }
+        it "initializes in an unshuffled order by suit" do
+          expect(deck[0..12].group_by{|c|c.suit.to_sym}.count).to be(1)
+        end
+        it "initializes in an unshuffled order by value" do
+          deck[0..12].reduce do |memo, card|
+            expect(memo.value < card.value).to be(true)
+            card
+          end
+        end
+      end
+      context "when initialized with {aces_high: false}" do
+        let(:deck) { Deck.new(aces_high: false) }
+        it "initalizes with aces low" do
+          expect(deck.aces_high?).to be(false)
+        end
+      end
+    end
+  end
+
+  describe '#find_card' do
+    context "when passed an argument" do
+      context "when the card exists" do
+        it "returns the card" do
+          card = deck.find_card(:ace, :spades)
+          expect(card.ace_of_spades?).to be(true)
+        end
+      end
+      context "when the card does not exist" do
+        it "returns nil" do
+          card = deck.find_card(:foo)
+          expect(card).to be_nil
+        end
+      end
+    end
+    context "when passed a block" do
+      it "returns the first card that yields the block as true" do
+        card = deck.find_card { |c| c.ace? }
+        expect(card.ace?).to be(true)
+      end
+    end
+  end
+
+  describe '#find_cards' do
+    context "when passed an argument" do
+      context "when there are cards that match the argument" do
+        it "returns an array of matching cards" do
+          cards = deck.find_cards(:ace)
+          expect(cards.count).to be(4)
+          cards.each { |c| expect(c.ace?).to be(true) }
+        end
+      end
+      context "when no cards match" do
+        it "returns an empty array" do
+          cards = deck.find_cards(:foo)
+          expect(cards.empty?).to be(true)
+        end
+      end
+    end
+    context "when passed a block" do
+      it "returns cards that yield as true" do
+        cards = deck.find_cards { |c| c.ace? }
+        expect(cards.count).to be(4)
+        cards.each { |c| expect(c.ace?).to be(true) }
+      end
+    end
+  end
+
+  describe '#add_card' do
+    it "adds specified card to self" do
+      deck.add_card('ace', 'spades')
+      expect(deck.count).to be(53)
+      expect(deck.last.to_s).to eq('Ace of Spades')
+    end
+    it "adds self as card.deck" do
+      expect(deck.sample.deck).to be(deck)
+    end
+  end
+
+  describe '#remove_cards' do
+    context "when passed an argument" do
+      let(:aces) { deck.remove_cards(:ace) }
+      it "removes matching cards from the deck" do
+        expect(aces.count).to be(4)
+        expect(deck.find{|c|c.ace?}).to be_nil
+      end
+    end
+    context "when passed a block" do
+      let(:spades) { deck.remove_cards {|c|c.spade?} }
+      it "removes cards that yield to true" do
+        expect(spades.count).to be(13)
+        expect(deck.find{|c|c.spade?}).to be_nil
+      end
+    end
+  end
+  
+  describe '#aces_high?' do
+    context "when aces are high" do
+      it "returns true" do
+        expect(deck.aces_high?).to be(true)
+      end
+    end
+    context "when aces are low" do
+      it "returns false" do
+        deck.aces_high = false
+        expect(deck.aces_high?).to be(false)
+      end
+    end
+  end
+
+  describe '#jokers?' do
+    context "there is a joker or jokers in the deck" do
+      it "returns true" do
+        deck.add_card(:joker)
+        expect(deck.jokers?).to be(true)
+      end
+    end
+    context "when there are no jokers" do
+      it "returns false" do
+        expect(deck.jokers?).to be(false)
+      end
+    end
+  end
+
+  describe '#deal' do
+    context "when called with no argument" do
+      it "deals 1 card when called with no argument" do
+         expect(deck.deal).to be_a(Card)
+      end
+    end
+    context "when called with an integer argument" do
+      it "deals multiple cards in an array when called with an integer argument" do
+        cards = deck.deal(10)
+        expect(cards.count).to be(10)
+        expect(cards.all?{|c|c.instance_of?(Card)}).to be(true)
+      end
+    end
+    it "removes dealt cards from deck" do
+       deck.deal
+       expect(deck.count).to be(51)
+       deck.deal(9)
+       expect(deck.count).to be(42)
+    end
+    it "stores dealt cards in another array" do
+      expect(deck.deal).to be(deck.dealt.first)
+      deck.deal(9)
+      expect(deck.dealt.count).to be(10)
+    end
+  end
+
+  describe '#shuffle!' do
+    it "shuffles the deck" do
+      dup = deck.dup
+      expect(deck.shuffle!).to_not eq(dup)
+    end
+    it "returns dealt cards to the deck before shuffling" do
+      deck.deal(10)
+      deck.shuffle!
+      expect(deck.count).to be(52)
+    end
+  end
+
+  describe '#shuffle' do
+    it "shuffles the deck non-destructively" do
+      expect(deck.shuffle).to_not be(deck)
+    end
+    it "returns dealt cards to the deck before shuffling" do
+      deck.deal(10)
+      expect(deck.count).to be(42)
+      expect(deck.shuffle.count).to be(52)
+    end
+  end
+
+  describe '#unshuffle!' do
+    let(:deck) { Deck.new(jokers: true) }
+    it "returns any dealt cards to the deck" do
+      deck.deal(10)
+      expect(deck.unshuffle!.count).to be(54)
+    end
+    it "sorts the deck from lowest to highest" do
+      deck.remove_cards(:joker)
+      deck.unshuffle!.reduce do |memo, card|
+        expect(memo < card).to be(true)
+        card
+      end
+    end
+  end
+
+  describe '#unshuffle' do
+    let(:deck) { Deck.new(jokers: true, shuffle:true) }
+    it "it unshuffles nondestructively" do
+      deck.deal(10)
+      expect(deck.unshuffle.count).to be(54)
+      expect(deck.count).to be(44) 
+    end
+    it "sorts the deck from lowest to highest nondestructively" do
+      deck.remove_cards(:joker)
+      deck.unshuffle.reduce do |memo, card|
+        expect(memo < card).to be(true)
+        card
+      end
+      first_suit = deck[0..12].group_by{|c|c.suit.to_sym}
+      expect(first_suit.count).to_not be(1)
+    end
+  end
+
+  describe '#valid?' do
+    describe "without jokers" do
+      context "when valid" do
+        it "returns true" do
+          expect(deck.valid?).to be(true)
+        end
+      end
+      context "when invalid" do
+        context "when wrong length" do
+          it "returns false" do
+            deck.remove_cards(:spades)
+            expect(deck.valid?).to be(false)
+          end
+        end
+        context "when wrong cards" do
+          it "returns false" do
+            deck.remove_cards(:ace, :spades)
+            deck.add_card(:king, :spades)
+            expect(deck.valid?).to be(false)
+          end
+        end
+      end
+    end
+  end
+  describe "with jokers" do
+    let(:deck) { Deck.new(jokers: true) }
+    context "when valid" do
+      it "returns true" do
+        expect(deck.valid?).to be(true)
+      end
+    end
+    context "when invalid" do
+      context "when wrong cards" do
+        it "returns false" do
+          deck.remove_cards(:ace, :spades)
+          deck.add_card(:joker)
+          expect(deck.valid?).to be(false)
+        end
+      end
+    end
+  end
+end