bridge 0.1.4 → 0.2.0

data/test/bridge_test.rb

@@ -0,0 +1,118 @@
+require "helper"
+
+describe Bridge do
+  it "negative number is not valid deal id" do
+    refute Bridge.deal_id?(-1)
+  end
+
+  it "number of possible bridge deals is not valid deal id" do
+    refute Bridge.deal_id?(Bridge::DEALS)
+  end
+
+  it "return partner of direction" do
+    assert_equal "N", Bridge.partner_of("S")
+    assert_equal "S", Bridge.partner_of("N")
+    assert_equal "E", Bridge.partner_of("W")
+    assert_equal "W", Bridge.partner_of("E")
+  end
+
+  it "return side of direction" do
+    assert_equal "NS", Bridge.side_of("S")
+    assert_equal "NS", Bridge.side_of("N")
+    assert_equal "EW", Bridge.side_of("W")
+    assert_equal "EW", Bridge.side_of("E")
+  end
+
+  it "return next direction" do
+    assert_equal "E", Bridge.next_direction("N")
+    assert_equal "S", Bridge.next_direction("E")
+    assert_equal "W", Bridge.next_direction("S")
+    assert_equal "N", Bridge.next_direction("W")
+    assert_equal "N", Bridge.next_direction(nil)
+  end
+
+  it "return vulnerable for given deal nr" do
+    assert_equal "NONE", Bridge.vulnerable_in_deal(nil)
+
+    assert_equal "NONE", Bridge.vulnerable_in_deal(1)
+    assert_equal "NS", Bridge.vulnerable_in_deal(2)
+    assert_equal "EW", Bridge.vulnerable_in_deal(3)
+    assert_equal "BOTH", Bridge.vulnerable_in_deal(4)
+
+    assert_equal "NS", Bridge.vulnerable_in_deal(5)
+    assert_equal "EW", Bridge.vulnerable_in_deal(6)
+    assert_equal "BOTH", Bridge.vulnerable_in_deal(7)
+    assert_equal "NONE", Bridge.vulnerable_in_deal(8)
+
+    assert_equal "EW", Bridge.vulnerable_in_deal(9)
+    assert_equal "BOTH", Bridge.vulnerable_in_deal(10)
+    assert_equal "NONE", Bridge.vulnerable_in_deal(11)
+    assert_equal "NS", Bridge.vulnerable_in_deal(12)
+
+    assert_equal "BOTH", Bridge.vulnerable_in_deal(13)
+    assert_equal "NONE", Bridge.vulnerable_in_deal(14)
+    assert_equal "NS", Bridge.vulnerable_in_deal(15)
+    assert_equal "EW", Bridge.vulnerable_in_deal(16)
+
+    assert_equal "NONE", Bridge.vulnerable_in_deal(17)
+    assert_equal "NS", Bridge.vulnerable_in_deal(18)
+    assert_equal "EW", Bridge.vulnerable_in_deal(19)
+    assert_equal "BOTH", Bridge.vulnerable_in_deal(20)
+  end
+
+  describe "bid regexp" do
+    it "matches 1S" do
+      assert_equal "1S", "1SS".match(Bridge::BID_REGEXP)[:bid]
+    end
+
+    it "matches 7NT" do
+      assert_equal "7NT", "7NTE".match(Bridge::BID_REGEXP)[:bid]
+    end
+
+    it "does not match 8NT" do
+      assert_nil "8NTE".match(Bridge::BID_REGEXP)
+    end
+  end
+
+  describe "modifier regexp" do
+    it "matches X" do
+      assert_equal "X", "1SXS".match(Bridge::MODIFIER_REGEXP)[:modifier]
+    end
+
+    it "matches XX" do
+      assert_equal "XX", "1NTXXS".match(Bridge::MODIFIER_REGEXP)[:modifier]
+    end
+  end
+
+  describe "result regexp" do
+    it "matches =" do
+      assert_equal "=", "1SNXE=".match(Bridge::RESULT_REGEXP)[:result]
+    end
+
+    it "matches -12" do
+      assert_equal "-12", "12NTNXE-12".match(Bridge::RESULT_REGEXP)[:result]
+    end
+  end
+
+  describe "contract regexp" do
+    it "matches 1SN" do
+      assert_equal "1SXN", "1SXN-2".match(Bridge::CONTRACT_REGEXP)[:contract]
+    end
+
+    it "matches 7NTXXS" do
+      assert_equal "7NTXXS", "7NTXXS=".match(Bridge::CONTRACT_REGEXP)[:contract]
+    end
+  end
+
+  describe "score regexp" do
+    it "matches 7NTXXS-2" do
+      matched = "7NTXXS-2".match(Bridge::SCORE_REGEXP)
+      assert_equal "7NTXXS-2", matched[:score]
+      assert_equal "7NTXXS", matched[:contract]
+      assert_equal "7NT", matched[:bid]
+      assert_equal "XX", matched[:modifier]
+      assert_equal "S", matched[:direction]
+      assert_equal "-2", matched[:result]
+    end
+  end
+end

data/test/{test_card.rb → card_test.rb}

@@ -1,57 +1,57 @@
 require "helper"
 
-class TestCard < Test::Unit::TestCase
-  test "H2 is a valid card" do
+describe Bridge::Card do
+  it "H2 is a valid card" do
     card = Bridge::Card.new("H2")
     assert "H", card.suit
     assert "2", card.value
   end
 
-  test "ST is a valid card" do
+  it "ST is a valid card" do
     card = Bridge::Card.new("ST")
     assert "S", card.suit
     assert "T", card.value
   end
 
-  test "CQ is a valid card" do
+  it "CQ is a valid card" do
     card = Bridge::Card.new("CQ")
     assert "C", card.suit
     assert "Q", card.value
   end
 
-  test "NT1 is not a valid card" do
+  it "NT1 is not a valid card" do
     assert_raises(ArgumentError) do
       Bridge::Card.new("NT1")
     end
   end
 
-  test "1H is not a valid card" do
+  it "1H is not a valid card" do
     assert_raises(ArgumentError) do
       Bridge::Card.new("1H")
     end
   end
 
-  test "ST is lower than SJ" do
+  it "ST is lower than SJ" do
     assert Bridge::Card.new("ST") < Bridge::Card.new("SJ")
   end
 
-  test "H2 has no hcp" do
+  it "H2 has no hcp" do
     assert_equal 0, Bridge::Card.new("H2").hcp
   end
 
-  test "SJ has 1 hcp" do
+  it "SJ has 1 hcp" do
     assert_equal 1, Bridge::Card.new("SJ").hcp
   end
 
-  test "CQ has 2 hcp" do
+  it "CQ has 2 hcp" do
     assert_equal 2, Bridge::Card.new("CQ").hcp
   end
 
-  test "CK has 3 hcp" do
+  it "CK has 3 hcp" do
     assert_equal 3, Bridge::Card.new("CK").hcp
   end
 
-  test "DA has 4 hcp" do
+  it "DA has 4 hcp" do
     assert_equal 4, Bridge::Card.new("DA").hcp
   end
 end

data/test/{test_chicago.rb → chicago_test.rb}

@@ -1,48 +1,48 @@
 require "helper"
 
-class TestChicago < Test::Unit::TestCase
-  test "raises ArgumentError when invalid honour card points provided" do
+describe Bridge::Points::Chicago do
+  it "raises ArgumentError when invalid honour card points provided" do
     assert_raises(ArgumentError) do
       Bridge::Points::Chicago.new(:hcp => 15, :points => 100)
     end
   end
 
-  test "set default vulnerable to false" do
+  it "set default vulnerable to false" do
     imp = Bridge::Points::Chicago.new(:hcp => 40, :points => -100)
-    assert_false imp.vulnerable
+    refute imp.vulnerable
   end
 
-  test "return vulnerable boolean" do
+  it "return vulnerable boolean" do
     imp = Bridge::Points::Chicago.new(:hcp => 20, :points => 100, :vulnerable => true)
     assert imp.vulnerable?
   end
 
-  test "return points to make when vulnerable" do
+  it "return points to make when vulnerable" do
     imp = Bridge::Points::Chicago.new(:hcp => 23, :points => 100, :vulnerable => true)
     assert_equal 110, imp.points_to_make
   end
 
-  test "return nil when points are not in range" do
+  it "return nil when points are not in range" do
     imp = Bridge::Points::Chicago.new(:hcp => 20, :points => 45)
     assert_equal nil, imp.imps
   end
 
-  test "return high value of imp range" do
+  it "return high value of imp range" do
     imp = Bridge::Points::Chicago.new(:hcp => 22, :points => 110)
     assert_equal 1, imp.imps
   end
 
-  test "return points to make when not vulnerable" do
+  it "return points to make when not vulnerable" do
     imp = Bridge::Points::Chicago.new(:hcp => 23, :points => 100, :vulnerable => false)
     assert_equal 110, imp.points_to_make
   end
 
-  test "return positive imps" do
+  it "return positive imps" do
     imp = Bridge::Points::Chicago.new(:hcp => 21, :points => 100)
     assert_equal 2, imp.imps
   end
 
-  test "return negative imps" do
+  it "return negative imps" do
     imp = Bridge::Points::Chicago.new(:hcp => 21, :points => -100)
     assert_equal -4, imp.imps
   end

data/test/deal_test.rb

@@ -0,0 +1,225 @@
+require "helper"
+
+describe Bridge::Deal do
+  it "first deal conversion" do
+    id = 0
+    deal = Bridge::Deal.from_id(id)
+    assert deal.valid?
+    assert_equal %w(SA SK SQ SJ ST S9 S8 S7 S6 S5 S4 S3 S2).map { |c| Bridge::Card.new(c) }, deal.n
+    assert_equal %w(HA HK HQ HJ HT H9 H8 H7 H6 H5 H4 H3 H2).map { |c| Bridge::Card.new(c) }, deal.e
+    assert_equal %w(DA DK DQ DJ DT D9 D8 D7 D6 D5 D4 D3 D2).map { |c| Bridge::Card.new(c) }, deal.s
+    assert_equal %w(CA CK CQ CJ CT C9 C8 C7 C6 C5 C4 C3 C2).map { |c| Bridge::Card.new(c) }, deal.w
+    assert_equal id, deal.id
+  end
+
+  it "first deal hcp" do
+    deal = Bridge::Deal.from_id(0)
+    assert_equal 10, deal.hcp("N")
+    assert_equal 10, deal.hcp("E")
+    assert_equal 10, deal.hcp("S")
+    assert_equal 10, deal.hcp("W")
+    assert_equal 20, deal.hcp("NS")
+    assert_equal 20, deal.hcp("EW")
+  end
+
+  it "last deal conversion" do
+    id = Bridge::DEALS - 1
+    deal = Bridge::Deal.from_id(id)
+    assert deal.valid?
+    assert_equal %w(CA CK CQ CJ CT C9 C8 C7 C6 C5 C4 C3 C2).map { |c| Bridge::Card.new(c) }, deal.n
+    assert_equal %w(DA DK DQ DJ DT D9 D8 D7 D6 D5 D4 D3 D2).map { |c| Bridge::Card.new(c) }, deal.e
+    assert_equal %w(HA HK HQ HJ HT H9 H8 H7 H6 H5 H4 H3 H2).map { |c| Bridge::Card.new(c) }, deal.s
+    assert_equal %w(SA SK SQ SJ ST S9 S8 S7 S6 S5 S4 S3 S2).map { |c| Bridge::Card.new(c) }, deal.w
+    assert_equal id, deal.id
+  end
+
+  it "last deal hcp" do
+    deal = Bridge::Deal.from_id(Bridge::DEALS - 1)
+    assert_equal 10, deal.hcp("N")
+    assert_equal 10, deal.hcp("E")
+    assert_equal 10, deal.hcp("S")
+    assert_equal 10, deal.hcp("W")
+    assert_equal 20, deal.hcp("NS")
+    assert_equal 20, deal.hcp("EW")
+  end
+
+  it "deal no 1 000 000 000 000" do
+    id = 1_000_000_000_000
+    deal = Bridge::Deal.from_id(id)
+    assert deal.valid?
+    assert_equal id, deal.id
+  end
+
+  it "sample deal to id conversion" do
+    deal = Bridge::Deal.new("N" => %w(SA SK SQ SJ HA HK HQ DA DK DQ CA CK CQ),
+                            "E" => %w(ST S9 S8 S7 S6 S5 S4 S3 S2 HJ HT H9 H8),
+                            "S" => %w(H7 H6 H5 H4 H3 H2 DJ DT D9 D8 D7 D6 D5),
+                            "W" => %w(D4 D3 D2 CJ CT C9 C8 C7 C6 C5 C4 C3 C2))
+    assert deal.valid?
+    id = deal.id
+    assert_equal deal, Bridge::Deal.from_id(id)
+  end
+
+  it "deal with doubled cards is not valid deal" do
+    deal = Bridge::Deal.new("N" => %w(SA SA SQ SJ HA HK HQ DA DK DQ CA CK CQ),
+                            "E" => %w(ST S9 S8 S7 S6 S5 S4 S3 S2 HJ HT H9 H8),
+                            "S" => %w(H7 H6 H5 H4 H3 H2 DJ DT D9 D8 D7 D6 D5),
+                            "W" => %w(D4 D3 D2 CJ CT C9 C8 C7 C6 C5 C4 C3 C2))
+    refute deal.valid?
+  end
+
+  it "deal with different length hands is not valid deal" do
+    deal = Bridge::Deal.new("N" => %w(SA SK SQ SJ HA HK HQ DA DK DQ CA CK CQ ST),
+                            "E" => %w(S9 S8 S7 S6 S5 S4 S3 S2 HJ HT H9 H8),
+                            "S" => %w(H7 H6 H5 H4 H3 H2 DJ DT D9 D8 D7 D6 D5),
+                            "W" => %w(D4 D3 D2 CJ CT C9 C8 C7 C6 C5 C4 C3 C2))
+    refute deal.valid?
+  end
+
+  it "random deal id is valid deal id" do
+    id = Bridge::Deal.random_id
+    assert Bridge.deal_id?(id)
+  end
+
+  it "random deal is valid deal" do
+    deal = Bridge::Deal.random
+    assert deal.valid?
+  end
+
+  it "comparison of two deals" do
+    deal1 = Bridge::Deal.from_id(1_000_000_000_000_000)
+    deal2 = Bridge::Deal.from_id(9_000_000_000_000_000)
+    assert deal1 < deal2
+  end
+
+  it "fetching wrong direction raises an error" do
+    deal = Bridge::Deal.random
+    assert_raises(ArgumentError) do
+      deal[:h]
+    end
+  end
+
+  it "passing incorrect id to from_id raises an error" do
+    assert_raises(ArgumentError) do
+      Bridge::Deal.from_id(-1)
+    end
+  end
+
+  it "owner returns correct direction" do
+    deal = Bridge::Deal.new({ "N" => ["SK", "S9", "S7", "S6", "S4", "S2", "HA", "HJ", "H2", "D7", "D2", "C6", "C3"],
+                              "E" => ["SA", "SJ", "ST", "H3", "DA", "DK", "DT", "D9", "D8", "D5", "D4", "CK", "CJ"],
+                              "S" => ["S8", "S5", "S3", "HK", "HQ", "HT", "H8", "H4", "DQ", "D3", "CQ", "C4", "C2"],
+                              "W" => ["SQ", "H9", "H7", "H6", "H5", "DJ", "D6", "CA", "CT", "C9", "C8", "C7", "C5"] })
+
+    assert_equal "N", deal.owner("SK")
+    assert_equal "N", deal.owner("C3")
+    assert_equal "E", deal.owner("SJ")
+    assert_equal "E", deal.owner("CK")
+    assert_equal "S", deal.owner("S3")
+    assert_equal "S", deal.owner("CQ")
+    assert_equal "W", deal.owner("H6")
+    assert_equal "W", deal.owner("C9")
+  end
+
+  it "to_hash returns hash" do
+    deal = Bridge::Deal.from_id(0)
+    assert_equal Hash, deal.to_hash.class
+  end
+
+  it "to_hash returns hash with arrays of strings" do
+    deal = Bridge::Deal.from_id(0)
+    assert_equal String, deal.to_hash["N"].first.class
+  end
+
+  describe "sort" do
+    before do
+      @deal = Bridge::Deal.new({ "N" => ["SK", "S9", "S7", "S6", "S4", "HA", "HJ", "H3", "H2", "D7", "D2", "C6", "C3"],
+                                "E" => ["SA", "SQ", "SJ", "ST", "S2", "DA", "DK", "DT", "D9", "D8", "D5", "CK", "CJ"],
+                                "S" => ["S8", "S5", "S3", "HK", "HQ", "HT", "H8", "H4", "DQ", "D3", "CQ", "C4", "C2"],
+                                "W" => ["H9", "H7", "H6", "H5", "DJ", "D6", "D4", "CA", "CT", "C9", "C8", "C7", "C5"] })
+    end
+
+    it "split cards by color for given direction" do
+      expected = { "S" => @deal.n.select { |c| c.suit == "S" },
+                   "H" => @deal.n.select { |c| c.suit == "H" },
+                   "D" => @deal.n.select { |c| c.suit == "D" },
+                   "C" => @deal.n.select { |c| c.suit == "C" } }
+      assert_equal expected, @deal.cards_for("N")
+    end
+
+    it "return empty array if no cards" do
+      expected = { "S" => @deal.e.select { |c| c.suit == "S" },
+                   "H" => [],
+                   "D" => @deal.e.select { |c| c.suit == "D" },
+                   "C" => @deal.e.select { |c| c.suit == "C" } }
+      assert_equal expected, @deal.cards_for("E")
+    end
+
+    it "return sorted 4 colors" do
+      assert_equal ["S", "H", "C", "D"], @deal.send(:sort_colors, ["S", "H", "D", "C"])
+      assert_equal ["S", "H", "C", "D"], @deal.send(:sort_colors, ["H", "D", "S", "C"])
+      assert_equal ["S", "H", "C", "D"], @deal.send(:sort_colors, ["D", "S", "C", "H"])
+    end
+
+    it "return sorted 3 colors" do
+      assert_equal ["S", "H", "C"], @deal.send(:sort_colors, ["S", "H", "C"])
+      assert_equal ["H", "C", "D"], @deal.send(:sort_colors, ["H", "D", "C"])
+      assert_equal ["H", "S", "D"], @deal.send(:sort_colors, ["S", "H", "D"])
+      assert_equal ["S", "D", "C"], @deal.send(:sort_colors, ["S", "D", "C"])
+    end
+
+    it "return sorted 2 colors" do
+      assert_equal ["S", "H"], @deal.send(:sort_colors, ["S", "H"])
+      assert_equal ["S", "D"], @deal.send(:sort_colors, ["S", "D"])
+      assert_equal ["C", "D"], @deal.send(:sort_colors, ["D", "C"])
+      # assert_equal ["H", "C"], @deal.send(:sort_colors, ["H", "C"])
+    end
+
+    it "return sorted 4 colors with trump" do
+      assert_equal ["S", "H", "C", "D"], @deal.send(:sort_colors, ["S", "H", "D", "C"], "S")
+      assert_equal ["H", "S", "D", "C"], @deal.send(:sort_colors, ["H", "D", "S", "C"], "H")
+      assert_equal ["D", "S", "H", "C"], @deal.send(:sort_colors, ["D", "S", "C", "H"], "D")
+      assert_equal ["C", "H", "S", "D"], @deal.send(:sort_colors, ["D", "S", "C", "H"], "C")
+    end
+
+    it "return sorted 3 colors with trump" do
+      assert_equal ["S", "H", "C"], @deal.send(:sort_colors, ["S", "H", "C"], "S")
+      assert_equal ["H", "S", "C"], @deal.send(:sort_colors, ["S", "H", "C"], "H")
+      assert_equal ["S", "H", "D"], @deal.send(:sort_colors, ["S", "H", "D"], "S")
+      assert_equal ["D", "S", "H"], @deal.send(:sort_colors, ["S", "H", "D"], "D")
+    end
+
+    it "return sorted 2 colors with trump" do
+      assert_equal ["S", "H"], @deal.send(:sort_colors, ["S", "H"], "S")
+      assert_equal ["H", "S"], @deal.send(:sort_colors, ["S", "H"], "H")
+      assert_equal ["C", "S"], @deal.send(:sort_colors, ["S", "C"], "C")
+      assert_equal ["D", "H"], @deal.send(:sort_colors, ["H", "D"], "D")
+    end
+
+    it "sort hands by colors" do
+      expected =  {
+        "N" => ["SK", "S9", "S7", "S6", "S4", "HA", "HJ", "H3", "H2", "C6", "C3", "D7", "D2"],
+        "E" => ["SA", "SQ", "SJ", "ST", "S2", "DA", "DK", "DT", "D9", "D8", "D5", "CK", "CJ"],
+        "S" => ["S8", "S5", "S3", "HK", "HQ", "HT", "H8", "H4", "CQ", "C4", "C2", "DQ", "D3"],
+        "W" => ["H9", "H7", "H6", "H5", "CA", "CT", "C9", "C8", "C7", "C5", "DJ", "D6", "D4"]
+      }
+      assert_equal expected, @deal.sort_by_color!.to_hash
+    end
+
+    it "sort hands by colors with trump" do
+      expected = {
+        "N" => ["C6", "C3", "HA", "HJ", "H3", "H2", "SK", "S9", "S7", "S6", "S4", "D7", "D2"],
+        "E" => ["CK", "CJ", "DA", "DK", "DT", "D9", "D8", "D5", "SA", "SQ", "SJ", "ST", "S2"],
+        "S" => ["CQ", "C4", "C2", "HK", "HQ", "HT", "H8", "H4", "S8", "S5", "S3", "DQ", "D3"],
+        "W" => ["CA", "CT", "C9", "C8", "C7", "C5", "H9", "H7", "H6", "H5", "DJ", "D6", "D4"]
+      }
+      assert_equal expected, @deal.sort_by_color!("C").to_hash
+    end
+
+    it "not modify hands if sorted by color without bang" do
+      old_deal = @deal.to_hash
+      @deal.sort_by_color
+      assert_equal old_deal, @deal.to_hash
+    end
+  end
+end