gistfile1.txt

require 'test/unit'
require 'card'
require 'deck'

class CardTest < Test::Unit::TestCase
  def setup
  end

  def test_a_five_is_greater_than_a_two
    five_card = Card.new(5)
    two_card  = Card.new(2)
    assert(five_card > two_card)
  end

  def test_a_ten_is_less_than_a_king
    ten_card  = Card.new(10)
    king_card = Card.new('king')
    assert(ten_card < king_card)
  end

  def test_two_twos_are_equal
    two_card = Card.new(2)
    other_two_card = Card.new(2)
    assert_equal(two_card, two_card)
  end

  def test_setting_rank_with_string_vs_integer_doesnt_matter
    assert_nothing_raised {
      two_card = Card.new('2')
      other_two_card = Card.new(2)
      assert_equal(two_card, other_two_card)
    }
  end

  def test_card_constructor_rejects_invalid_arguments
    assert_raises(RuntimeError) {
      foo_card = Card.new('foo')
    }
  end

  def teardown
  end
end

class DeckTest < Test::Unit::TestCase
  def setup
    @deck = Deck.new
  end

  def test_size_of_new_deck_is_52
    assert_equal(@deck.size, 52)
  end

  def test_dealing_one_reduces_size_of_deck_by_one
    before_deal_size = @deck.size
    @deck.deal(1)
    assert(before_deal_size - 1 == @deck.size)
  end
  
  def test_dealing_five_reduces_size_of_deck_by_five
    before_deal_size = @deck.size
    @deck.deal(5)
    assert(before_deal_size - 5 == @deck.size)
  end
  
  def test_peek_shows_next_card_without_dealing_it
    card = @deck.peek
    assert(card)
    assert_equal(@deck.size, 52)
  end    
  
  def test_shuffling_changes_order_of_deck
    100.times do
      original_cards = @deck.cards
      assert_equal(@deck.shuffle.size, 52)
      assert(@deck.cards != original_cards)
    end
  end
  
  def test_shuffling_preserves_all_the_original_cards
    original_deck = @deck
    @deck.shuffle
    assert_equal(@deck.cards.sort, original_deck.cards.sort)
  end

  def teardown
  end
end

class Deck
  attr_accessor :cards
  SUITS = %w{clubs spades hearts diamonds}
  RANKS = %w{2 3 4 5 6 7 8 9 10 jack queen king ace}
  
  def initialize
    @cards = []
    SUITS.each do |suit|
      RANKS.each do |rank|
        @cards << Card.new(rank, suit)
      end
    end
  end
  
  def size
    @cards.size
  end
  
  def deal(num)
    num.times do
      @cards.shift
    end
  end
    
  def peek
    @cards.first
  end
  
  def shuffle
    original_deck = @cards
    @cards = []
    original_deck.size.times do 
      @cards << original_deck.delete_at(rand(original_deck.size))
    end
    self
  end
end

class Card
  include Comparable
  
  attr_accessor :value
  attr_accessor :suit
  
  def initialize(value, suit=nil)
    @value = case value.to_s.downcase
    when 'ace' 
      14
    when 'king'
      13
    when 'queen'
      12
    when 'jack'
      11
    else
      raise 'REJECTED' if value.to_i < 2 || value.to_i > 14
      value.to_i
    end
    @suit = suit
  end
  
  def <=>(other_card)
    value <=> other_card.value
  end
  
end