patience 0.1.0

data/test/patience/test_processable.rb

@@ -0,0 +1,159 @@
+require_relative 'helper'
+
+module Patience
+  class TestProcessable < TestCase
+
+    class Dummy
+      include Processable
+      attr_accessor :area, :card, :pile
+
+      def find_all(areas, mouse_pos)
+        @area = find_area_in(areas) { |area| area.hit?(mouse_pos) }
+        @pile = find_pile_in(areas) { |pile| pile.hit?(mouse_pos) }
+        @card = find_card_in(areas) { |card| card.hit?(mouse_pos) }
+      end
+    end
+
+    def setup
+      @dummy = Dummy.new
+      @mouse_pos_miss = Ray::Vector2[0, 0]
+      @mouse_pos_hit = Ray::Vector2[32, 166]
+      @deck = Deck.new
+      @areas = { :tableau    => Tableau.new(@deck.shuffle_off! 28),
+                 :stock      => Stock.new(@deck.shuffle_off! 24),
+                 :waste      => Waste.new,
+                 :foundation => Foundation.new }
+    end
+
+    test 'Processable can select entity in areas by certain conditions' do
+      assert_equal Tableau,
+                   @dummy.detect_in(@areas, :area) { |area|
+                     area.hit?(@mouse_pos_hit)
+                   }.class
+      assert_equal NilClass,
+                   @dummy.detect_in(@areas, :area) { |area|
+                     area.hit?(@mouse_pos_miss)
+                   }.class
+
+      assert_equal Pile,
+                   @dummy.detect_in(@areas, :pile) { |pile|
+                     pile.hit?(@mouse_pos_hit)
+                   }.class
+      assert_equal NilClass,
+                   @dummy.detect_in(@areas, :pile) { |pile|
+                     pile.hit?(@mouse_pos_miss)
+                   }.class
+
+      assert_equal Card,
+                   @dummy.detect_in(@areas, :card) { |card|
+                     card.hit?(@mouse_pos_hit)
+                   }.class
+      assert_equal NilClass,
+                   @dummy.detect_in(@areas, :card) { |card|
+                     card.hit?(@mouse_pos_miss)
+                   }.class
+
+      assert_raises(ArgumentError) do
+        @dummy.detect_in(@areas, :cake)  { |cake| cake.hit?(@mouse_pos_miss) }
+        @dummy.detect_in(@areas, :yadda) { |blah| blah.hit?(@mouse_pos_hit) }
+      end
+    end
+
+    test 'Processable can find an area' do
+      assert_equal Tableau, @dummy.find_area_in(@areas) { |area|
+                              area.hit?(@mouse_pos_hit)
+                            }.class
+      mouse_pos_hit_stock = Ray::Vector2[31, 65]
+      assert_equal Stock, @dummy.find_area_in(@areas) { |area|
+                            area.hit?(mouse_pos_hit_stock)
+                          }.class
+      assert_equal NilClass, @dummy.find_area_in(@areas) { |area|
+                               area.hit?(@mouse_pos_miss)
+                             }.class
+    end
+
+    test 'Processable can find a pile' do
+      assert_equal Pile, @dummy.find_pile_in(@areas) { |pile|
+                           pile.hit?(@mouse_pos_hit) && @hit_pile = pile
+                         }.class
+      assert @areas[:tableau].piles.include?(@hit_pile)
+      assert_equal NilClass, @dummy.find_pile_in(@areas) { |pile|
+                               pile.hit?(@mouse_pos_miss)
+                             }.class
+    end
+
+    test 'Processable can find a card' do
+      mouse_pos_hit_stock = Ray::Vector2[31, 65]
+      assert_equal Card, @dummy.find_card_in(@areas) { |card|
+                           card.hit?(@mouse_pos_hit)
+                         }.class
+      assert_equal Card, @dummy.find_card_in(@areas) { |card|
+                          card.hit?(mouse_pos_hit_stock) &&
+                          @hit_card = card
+                        }.class
+      assert @areas[:stock].cards.include?(@hit_card)
+      assert_equal NilClass, @dummy.find_card_in(@areas) { |card|
+                               card.hit?(@mouse_pos_miss)
+                             }.class
+    end
+
+    test 'Processable can represent data as array' do
+      assert_equal [nil, nil, nil], @dummy.to_a
+      @dummy.find_all(@areas, @mouse_pos_hit)
+      refute_nil @dummy.to_a.compact
+      assert_instance_of Tableau, @dummy.to_a.first
+      assert_kind_of     Area,    @dummy.to_a.first
+      assert_instance_of Pile,    @dummy.to_a[1]
+      assert_instance_of Card,    @dummy.to_a.last
+    end
+
+    test 'Processable can represent data as hash' do
+      assert_equal({ :area => nil, :pile => nil, :card => nil }, @dummy.to_h)
+      @dummy.find_all(@areas, @mouse_pos_hit)
+      refute_nil @dummy.to_h
+      assert_instance_of Tableau, @dummy.to_h[:area]
+      assert_kind_of     Area,    @dummy.to_h[:area]
+      assert_instance_of Pile,    @dummy.to_h[:pile]
+      assert_instance_of Card,    @dummy.to_h[:card]
+    end
+
+    test 'Processable can check for data existence' do
+      refute @dummy.something?
+      @dummy.find_all(@areas, @mouse_pos_hit)
+      assert @dummy.something?
+    end
+
+    test 'Processable can check for data abscence' do
+      assert @dummy.nothing?
+      @dummy.find_all(@areas, @mouse_pos_hit)
+      refute @dummy.nothing?
+    end
+
+    test 'Processable can count an offset' do
+      @dummy.find_all(@areas, @mouse_pos_hit)
+      assert_equal Ray::Vector2[-1, -1],
+                   @dummy.pick_up(@areas[:tableau].cards[0], @mouse_pos_hit)
+    end
+
+    test 'Processable can check, if Stock has been hit' do
+      @dummy.find_all(@areas, Ray::Vector2[40, 40])
+      assert @dummy.stock?
+    end
+
+    test 'Processable can check, if Waste has been hit' do
+      @dummy.find_all(@areas, Ray::Vector2[160, 40])
+      assert @dummy.waste?
+    end
+
+    test 'Processable can check, if Tableau has been hit' do
+      @dummy.find_all(@areas, Ray::Vector2[32, 166])
+      assert @dummy.tableau?
+    end
+
+    test 'Processable can check, if Foundation has been hit' do
+      @dummy.find_all(@areas, Ray::Vector2[590, 40])
+      assert @dummy.foundation?
+    end
+
+  end
+end

data/test/patience/test_rank.rb

@@ -0,0 +1,88 @@
+require_relative 'helper'
+
+module Patience
+  class TestRank < TestCase
+
+    def setup
+      @ranks = %w[Ace Two Three Four Five Six Seven
+                  Eight Nine Ten Jack Queen King]
+      @rank = Card::Rank::Five.new
+    end
+
+    test 'All ranks do exist' do
+      @ranks.each do |rank|
+        assert "Patience::Card::Rank::#{rank}".constantize.new
+      end
+    end
+
+    test 'Ranks are kind of Rank' do
+      @ranks.each do |rank|
+        assert_kind_of Patience::Card::Rank,
+                       "Patience::Card::Rank::#{rank}".constantize.new
+      end
+    end
+
+    test "An unreal rank can't be created" do
+      assert_raises(NameError) { Patience::Card::Rank::One.new }
+      assert_raises(NameError) { Patience::Card::Rank::Eleven.new }
+      assert_raises(NameError) { Patience::Card::Rank::Joker.new }
+    end
+
+    test 'A rank can be represented as Fixnum' do
+      @ranks.each_with_index do |rank, i|
+        assert_equal i+1, "Patience::Card::Rank::#{rank}".constantize.new.to_i
+      end
+    end
+
+    test 'A rank can be represented as String' do
+      @ranks.each do |rank|
+        assert_equal rank, "Patience::Card::Rank::#{rank}".constantize.new.to_s
+      end
+    end
+
+    test 'Ranks can be compared to each other' do
+      ace = Patience::Card::Rank::Ace.new
+      two = Patience::Card::Rank::Two.new
+      ten1 = Patience::Card::Rank::Ten.new
+      ten2 = Patience::Card::Rank::Ten.new
+
+      assert ace < two
+      refute ace > two
+      refute ace == two
+      assert ace != two
+      assert ten1 == ten2
+      refute ten1 > ten2
+      refute ten1 < ten2
+    end
+
+    test "A rank can be checked, if it's higher other rank by one" do
+      ace = Patience::Card::Rank::Ace.new
+      four = Patience::Card::Rank::Four.new
+      six = Patience::Card::Rank::Six.new
+
+      assert @rank.higher_by_one_than?(four)
+      refute four.higher_by_one_than?(@rank)
+      refute @rank.higher_by_one_than?(ace)
+      refute ace.higher_by_one_than?(@rank)
+      refute @rank.higher_by_one_than?(six)
+      assert six.higher_by_one_than?(@rank)
+    end
+
+    test "A rank can be checked, if it's an ace" do
+      ace_rank = Patience::Card::Rank::Ace.new
+      king_rank = Patience::Card::Rank::King.new
+
+      assert ace_rank.ace?
+      refute king_rank.ace?
+    end
+
+    test "A rank can be checked, if it's a king" do
+      ace_rank = Patience::Card::Rank::Ace.new
+      king_rank = Patience::Card::Rank::King.new
+
+      assert king_rank.king?
+      refute ace_rank.king?
+    end
+
+  end
+end

data/test/patience/test_stock.rb

@@ -0,0 +1,43 @@
+require_relative 'helper'
+
+module Patience
+  class TestStockArea < TestCase
+
+    def setup
+      @deck = Deck.new
+      @deck.cards.shuffle!
+      @stock = Stock.new(@deck.shuffle_off! 24)
+    end
+
+    test 'Stock is a child of Area' do
+      assert_kind_of Area, @stock
+    end
+
+    test 'Initial Stock has 24 cards' do
+      assert_equal 24, @stock.piles[0].size
+    end
+
+    test 'Initial Stock has 24 cards, even if there were provided more cards' do
+      deck = Deck.new
+      stock = Stock.new(deck.shuffle_off! 52)
+      assert_equal 24, @stock.piles[0].size
+    end
+
+    test 'Stock consists of one pile' do
+      assert_equal 1, @stock.piles.size
+    end
+
+    test 'The overall position of Stock can be gotten' do
+      assert_equal Ray::Vector2[31, 23], @stock.pos
+      assert_equal Ray::Vector2[31, 23], @stock.piles.first.pos
+    end
+
+    test 'Stock can be disposed in the window' do
+      @stock.send(:pos=, [0, 0])
+      assert_equal Ray::Vector2[0, 0], @stock.pos
+      @stock.send(:pos=, [200, 300])
+      assert_equal Ray::Vector2[200, 300], @stock.pos
+    end
+
+  end
+end

data/test/patience/test_suit.rb

@@ -0,0 +1,87 @@
+require_relative 'helper'
+
+module Patience
+  class TestCardSuit < TestCase
+
+    def setup
+      @suits = %w[Heart Diamond Spade Club]
+      @suit = Patience::Card::Suit::Diamond.new
+    end
+
+    test 'All suits do exist' do
+      @suits.each do |suit|
+        assert "Patience::Card::Suit::#{suit}".constantize.new
+      end
+    end
+
+    test 'Suits are kind of Suit' do
+      @suits.each do |suit|
+        assert_kind_of Patience::Card::Suit,
+                      "Patience::Card::Suit::#{suit}".constantize.new
+      end
+    end
+
+    test 'A suit can be represented as Fixnum' do
+      @suits.each_with_index do |suit, i|
+        assert_equal i+1, "Patience::Card::Suit::#{suit}".constantize.new
+      end
+    end
+
+    test 'A suit can be represented as String' do
+      @suits.each do |suit|
+        assert_equal suit+'s',
+                     "Patience::Card::Suit::#{suit}".constantize.new.to_s
+      end
+    end
+
+    test 'The Heart suit is red' do
+      assert Patience::Card::Suit::Heart.new.red?
+      refute Patience::Card::Suit::Heart.new.black?
+    end
+
+    test 'The Diamond suit is red' do
+      assert Patience::Card::Suit::Diamond.new.red?
+      refute Patience::Card::Suit::Diamond.new.black?
+    end
+
+    test 'The Spade suit is black' do
+      assert Patience::Card::Suit::Spade.new.black?
+      refute Patience::Card::Suit::Spade.new.red?
+    end
+
+    test 'The Club suit is black' do
+      assert Patience::Card::Suit::Club.new.black?
+      refute Patience::Card::Suit::Club.new.red?
+    end
+
+    test 'Suits can be compared to each other' do
+      spades = Patience::Card::Suit::Spade.new
+      hearts = Patience::Card::Suit::Heart.new
+      diamonds1 = Patience::Card::Suit::Diamond.new
+      diamonds2 = Patience::Card::Suit::Diamond.new
+
+      refute spades == hearts
+      assert spades != hearts
+      assert diamonds1 == diamonds2
+    end
+
+    test "Suits can be checked, if they're of the same color" do
+      red_suit = Patience::Card::Suit::Heart.new
+      black_suit = Patience::Card::Suit::Spade.new
+      assert @suit.same_color?(red_suit)
+      assert red_suit.same_color?(@suit)
+      refute @suit.same_color?(black_suit)
+      refute black_suit.same_color?(@suit)
+    end
+
+    test "Suits can be checked, if they're of the different colors" do
+      red_suit = Patience::Card::Suit::Heart.new
+      black_suit = Patience::Card::Suit::Spade.new
+      refute @suit.different_color?(red_suit)
+      refute red_suit.different_color?(@suit)
+      assert @suit.different_color?(black_suit)
+      assert black_suit.different_color?(@suit)
+    end
+
+  end
+end

data/test/patience/test_tableau.rb

@@ -0,0 +1,57 @@
+require_relative 'helper'
+
+module Patience
+  class TestTableauArea < TestCase
+
+    def setup
+      @deck = Deck.new
+      @tableau = Tableau.new(@deck.shuffle_off! 28)
+    end
+
+    test 'Tableau is a child of Area' do
+      assert_kind_of Area, @tableau
+    end
+
+    test 'Initial Tableau has 28 cards' do
+      cards = @tableau.piles.inject([]) { |cards, pile| cards << pile.cards }
+      assert_equal 28, cards.flatten.size
+    end
+
+    # Test, that initial tableau pile contains N+1 cards,
+    # where N is an index number of the pile, starting from 0.
+    test 'Initial Tableau piles have correct amount of cards' do
+      @tableau.piles.each_with_index do |pile, i|
+        assert_equal i+1, pile.size
+      end
+    end
+
+    test 'The overall position of Tableau can be gotten' do
+      assert_equal Ray::Vector2[31, 165], @tableau.pos
+      assert_equal Ray::Vector2[31, 165], @tableau.piles.first.pos
+    end
+
+    test 'Particular position of a pile in Tableau can be gotten' do
+      assert_equal Ray::Vector2[141, 165], @tableau.piles[1].pos
+      assert_equal Ray::Vector2[251, 165], @tableau.piles[2].pos
+      assert_equal Ray::Vector2[691, 165], @tableau.piles.last.pos
+    end
+
+    test 'Tableau can be disposed in the window' do
+      @tableau.send(:pos=, [0, 0])
+      assert_equal Ray::Vector2[0, 0],   @tableau.pos
+      assert_equal Ray::Vector2[660, 0], @tableau.piles.last.pos
+      @tableau.send(:pos=, [200, 300])
+      assert_equal Ray::Vector2[200, 300], @tableau.pos
+      assert_equal Ray::Vector2[860, 300], @tableau.piles.last.pos
+    end
+
+    test 'Cards in Tableau have a margin along the Y axis' do
+      assert_equal Ray::Vector2[31, 165], @tableau.piles[0].cards[0].pos
+      assert_equal Ray::Vector2[251, 191], @tableau.piles[2].cards[1].pos
+      assert_equal Ray::Vector2[471, 191], @tableau.piles[4].cards[1].pos
+      assert_equal Ray::Vector2[581, 217], @tableau.piles[5].cards[2].pos
+      assert_equal Ray::Vector2[691, 321], @tableau.piles.last.cards.last.pos
+    end
+
+  end
+end

data/test/patience/test_version.rb

@@ -0,0 +1,11 @@
+require_relative 'helper'
+
+module Patience
+  class TestVERSION < TestCase
+
+    test 'The Patience version is correct' do
+      assert_equal "0.1.0", Patience::VERSION
+    end
+
+  end
+end