bridge 0.1.4 → 0.2.0

data/lib/bridge/score.rb

@@ -1,41 +1,33 @@
 module Bridge
   class Score
-    attr_reader :tricks, :contract, :vulnerable
-    alias :vulnerable? :vulnerable
-
-    # Checks contract with result, i.e. "1NTX-1", "2S=", "6SXX+1"
-    # on Ruby >= 1.9 there are named groups :contract and :result
-    # on Ruby < 1.9 there are: contract on $1 and result on $5
-    if RUBY_VERSION >= "1.9"
-      REGEXP = Regexp.new %q{\A(?<contract>([1-7])([CDHS]|NT)(X{1,2})?)(?<result>=|\+[1-6]|-([1-9]|1[0-3]))\Z}
-    else
-      REGEXP = Regexp.new %q{\A(([1-7])([CDHS]|NT)(X{1,2})?)(=|\+[1-6]|-([1-9]|1[0-3]))\Z}
-    end
+    attr_reader :contract, :vulnerable, :tricks_number
 
     # Creates new score object
     #
     # ==== Example
-    #   Bridge::Score.new(:contract => "7SXX", :vulnerable => true, :tricks => "=")
-    def initialize(options = {})
-      @contract, @modifier = split_contract(options[:contract])
-      @tricks = calculate_tricks(options[:tricks])
-      raise ArgumentError, "invalid tricks: #{@tricks}" unless (0..13).include?(@tricks)
-      @vulnerable = options[:vulnerable] || false
+    #   Bridge::Score.new("7SXXN", "NS", 0)
+    def initialize(contract, vulnerable, tricks)
+      @contract      = contract
+      @vulnerable    = vulnerable
+      @tricks_number = calculate_tricks(tricks)
+    end
+
+    # Returns all possible contracts with given points
+    def self.with_points(points)
+      all_contracts.select { |contract, result| result == points }.keys.sort
     end
 
     # Returns nr of overtricks or undertricks. 0 if contract was made without them
     def result
-      tricks - tricks_to_make_contract
+      tricks_number - tricks_to_make_contract
     end
 
     # Returns string with nr of tricks relative to contract level
     def result_string
-      if result > 0
-        "+" << result.to_s
-      elsif result == 0
-        "="
-      else
-        result.to_s
+      case
+      when result > 0  then "+#{result}"
+      when result == 0 then "="
+      when result < 0  then result.to_s
       end
     end
 
@@ -49,24 +41,44 @@ module Bridge
       made? ? (made_contract_points + overtrick_points + bonus) : undertrick_points
     end
 
-    # Returns all possible contracts with given points
-    def self.with_points(points)
-      contracts = all_contracts.select { |contract, result| result == points }
-      contracts.respond_to?(:keys) ? contracts.keys.sort : contracts.map { |c| c.first }.sort # Ruby 1.8.* compatibility
+    # Returns if declarer side is vulnerable
+    def vulnerable?
+      case vulnerable
+      when "BOTH" then true
+      when "NONE" then false
+      else
+        vulnerable.split("").include?(declarer)
+      end
     end
 
-    # private
+    private
+
+    def contract_bid
+      @contract_bid ||= Bid.new(contract.match(Bridge::CONTRACT_REGEXP)[:bid])
+    end
+
+    def declarer
+      @declarer ||= contract.match(Bridge::CONTRACT_REGEXP)[:direction]
+    end
 
     def tricks_to_make_contract
-      contract.level.to_i + 6
+      @tricks_to_make_contract ||= contract_bid.level.to_i + 6
     end
 
     def doubled?
-      @modifier == 2
+      modifier == 2
     end
 
     def redoubled?
-      @modifier == 4
+      modifier == 4
+    end
+
+    def modifier
+      case contract.match(Bridge::CONTRACT_REGEXP)[:modifier]
+      when nil  then 1
+      when "X"  then 2
+      when "XX" then 4
+      end
     end
 
     def bonus
@@ -84,7 +96,7 @@ module Bridge
     end
 
     def grand_slam_bonus
-      if made? and contract.grand_slam?
+      if made? and contract_bid.grand_slam?
         vulnerable? ? 1500 : 1000
       else
         0
@@ -92,7 +104,7 @@ module Bridge
     end
 
     def small_slam_bonus
-      if made? and contract.small_slam?
+      if made? and contract_bid.small_slam?
         vulnerable? ? 750 : 500
       else
         0
@@ -108,11 +120,11 @@ module Bridge
     end
 
     def first_trick_points
-      contract.no_trump? ? 40 : single_trick_points
+      contract_bid.no_trump? ? 40 : single_trick_points
     end
 
     def single_trick_points
-      contract.minor? ? 20 : 30
+      contract_bid.minor? ? 20 : 30
     end
 
     def undertrick_points
@@ -120,7 +132,7 @@ module Bridge
     end
 
     def made_contract_points
-      first_trick_points * @modifier + (contract.level.to_i - 1) * single_trick_points * @modifier
+      first_trick_points * modifier + (contract_bid.level.to_i - 1) * single_trick_points * modifier
     end
 
     def overtrick_points
@@ -136,7 +148,7 @@ module Bridge
     # TODO: do some refactoring
     def vulnerable_undertrick_points
       if !made?
-        p = -100 * @modifier
+        p = -100 * modifier
         if result < -1
           return p += (result + 1) * 300 if doubled?
           return p += (result + 1) * 600 if redoubled?
@@ -150,7 +162,7 @@ module Bridge
 
     def not_vulnerable_undertrick_points
       if !made?
-        p = -50 * @modifier
+        p = -50 * modifier
         if [-3, -2].include?(result)
           return p += (result + 1) * 200 if doubled?
           return p += (result + 1) * 400 if redoubled?
@@ -180,21 +192,15 @@ module Bridge
       end
     end
 
-    def split_contract(contract)
-      contract = contract.gsub(/(X+)/, "")
-      modifier = $1.nil? ? 1 : $1.to_s.size * 2
-      [Bridge::Bid.new(contract), modifier]
-    end
-
     def self.all_contracts
       result = {}
       contracts = %w(1 2 3 4 5 6 7).inject([]) do |bids, level|
         bids += ["H/S", "C/D", "NT"].map { |suit| level + suit }
       end
       (contracts + contracts.map { |c| c + "X" } + contracts.map { |c| c + "XX" } ).each do |contract|
-        [true, false].each do |vulnerable|
+        ["BOTH", "NONE"].each do |vulnerable|
           (0..13).each do |tricks|
-            score = new(:contract => contract.sub("H/S", "S").sub("C/D", "C"), :tricks => tricks, :vulnerable => vulnerable)
+            score = new(contract.sub("H/S", "S").sub("C/D", "C").sub("NT", "NT") + "N", vulnerable, tricks)
             result[contract + score.result_string + (score.vulnerable? ? "v" : "")] = score.points
           end
         end

data/lib/bridge/trick.rb

@@ -8,11 +8,11 @@ module Bridge
     end
 
     def winner(trump = nil)
-      winner_in_suit(trump) || winner_in_suit(@suit)
+      winner_in_suit(trump) || winner_in_suit(suit)
     end
 
     def complete?
-      @cards.size == 4
+      cards.size == 4
     end
 
     def incomplete?
@@ -22,7 +22,7 @@ module Bridge
     private
 
     def winner_in_suit(suit)
-      @cards.select { |c| c.suit == suit }.max
+      cards.select { |c| c.suit == suit }.max
     end
   end
 end

data/lib/bridge/version.rb

@@ -1,3 +1,3 @@
 module Bridge
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/test/auction_test.rb

@@ -0,0 +1,133 @@
+require "helper"
+
+describe Bridge::Auction do
+  it "raises on invalid bids" do
+    assert_raises ArgumentError do
+      Bridge::Auction.new("N", ["8NT"])
+    end
+  end
+
+  describe "directions" do
+    it "returns empty array when no bids" do
+      auction = Bridge::Auction.new("N", [])
+      assert_equal [], auction.directions
+    end
+
+    it "returns directions" do
+      auction = Bridge::Auction.new("N", ["1NT", "PASS", "PASS", "X", "PASS"])
+      assert_equal ["N", "E", "S", "W", "N"], auction.directions
+    end
+  end
+
+  describe "#next_direction" do
+    it "returns next direction" do
+      auction = Bridge::Auction.new("N", ["1NT", "PASS", "PASS", "X", "PASS"])
+      assert_equal "E", auction.next_direction
+    end
+
+    it "returns dealer direction when no bids" do
+      auction = Bridge::Auction.new("S", [])
+      assert_equal "S", auction.next_direction
+    end
+  end
+
+  describe "#finished?" do
+    it "returns false when not finished" do
+      refute Bridge::Auction.new("N", ["2NT"]).finished?
+    end
+
+    it "returns true when finished" do
+      assert Bridge::Auction.new("N", ["2NT", "PASS", "PASS", "PASS"]).finished?
+    end
+  end
+
+  describe "#contract" do
+    it "returns nil when no contract" do
+      assert_nil Bridge::Auction.new("N", ["PASS"]).contract
+    end
+
+    it "returns current contract" do
+      assert_equal "2SN", Bridge::Auction.new("N", ["2S", "PASS"]).contract
+    end
+
+    it "returns current contract with modifier" do
+      assert_equal "2SXN", Bridge::Auction.new("N", ["2S", "X", "PASS"]).contract
+    end
+
+    it "returns current contract without modifier" do
+      assert_equal "2NTS", Bridge::Auction.new("N", ["2S", "X", "2NT", "PASS"]).contract
+    end
+  end
+
+  describe "#declarer" do
+    it "returns declarer direction" do
+      assert_equal "W", Bridge::Auction.new("E", ["2S", "X", "2NT", "PASS", "PASS", "PASS"]).declarer
+    end
+  end
+
+  describe "#bid_allowed?" do
+    it "returns false if finished" do
+      refute Bridge::Auction.new("N", ["1NT", "PASS", "PASS", "PASS"]).bid_allowed?("PASS")
+    end
+
+    it "returns true if PASS" do
+      assert Bridge::Auction.new("N", ["1NT", "PASS", "PASS"]).bid_allowed?("PASS")
+    end
+
+    it "returns false if bid is lower than previous" do
+      refute Bridge::Auction.new("N", ["1NT", "PASS"]).bid_allowed?("1S")
+    end
+
+    it "returns true if bid is higher than previous" do
+      assert Bridge::Auction.new("N", ["1NT", "PASS", "X"]).bid_allowed?("2C")
+    end
+
+    it "returns true if bid is first contract" do
+      assert Bridge::Auction.new("N", ["PASS"]).bid_allowed?("2C")
+    end
+
+    it "returns true if bid is double on previous contract" do
+      assert Bridge::Auction.new("N", ["1C"]).bid_allowed?("X")
+    end
+
+    it "returns true if bid is double on previous 2 bids contract" do
+      assert Bridge::Auction.new("N", ["1C", "PASS", "PASS"]).bid_allowed?("X")
+    end
+
+    it "returns false if bid is double on partner contract" do
+      refute Bridge::Auction.new("N", ["1C", "PASS"]).bid_allowed?("X")
+    end
+
+    it "returns false if bid is double on PASS" do
+      refute Bridge::Auction.new("N", ["PASS"]).bid_allowed?("X")
+    end
+
+    it "returns false if bid is double on doubled contract" do
+      refute Bridge::Auction.new("N", ["1C", "X", "PASS"]).bid_allowed?("X")
+    end
+
+    it "returns true if bid is redouble on doubled previous contract" do
+      assert Bridge::Auction.new("N", ["1C", "X"]).bid_allowed?("XX")
+    end
+
+    it "returns true if bid is redouble on 2 bids previous dobuled contract" do
+      assert Bridge::Auction.new("N", ["1C", "X", "PASS", "PASS"]).bid_allowed?("XX")
+    end
+
+    it "returns false if bid is redouble on partners double" do
+      refute Bridge::Auction.new("N", ["1C", "X", "PASS"]).bid_allowed?("XX")
+    end
+
+    it "returns false if bid is redouble on not doubled contract" do
+      refute Bridge::Auction.new("N", ["1C", "PASS", "PASS"]).bid_allowed?("XX")
+    end
+
+    it "returns false if bid is redouble on redoubled contract" do
+      refute Bridge::Auction.new("N", ["1C", "X", "XX", "PASS"]).bid_allowed?("XX")
+    end
+
+    it "returns true if 2 PASS in the auction" do
+      assert Bridge::Auction.new("N", ["PASS", "1D", "PASS", "PASS", "1H"]).bid_allowed?("PASS")
+    end
+  end
+end

data/test/bid_test.rb

@@ -0,0 +1,135 @@
+require "helper"
+
+describe Bridge::Bid do
+  it "pas is not a valid bid" do
+    assert_raises(ArgumentError) do
+      Bridge::Bid.new("pas")
+    end
+  end
+
+  it "case doesn't matter in bid" do
+    assert_equal "PASS", Bridge::Bid.new("pass").to_s
+    assert_equal "X", Bridge::Bid.new("x").to_s
+    assert_equal "XX", Bridge::Bid.new("xx").to_s
+    assert_equal "1NT", Bridge::Bid.new("1nt").to_s
+  end
+
+  it "pass is a valid bid" do
+    bid = Bridge::Bid.new("PASS")
+    assert bid.pass?
+    refute bid.double?
+    refute bid.redouble?
+    refute bid.modifier?
+    refute bid.contract?
+    assert_nil bid.level
+    assert_nil bid.suit
+  end
+
+  it "double is a valid bid" do
+    bid = Bridge::Bid.new("X")
+    refute bid.pass?
+    assert bid.double?
+    refute bid.redouble?
+    assert bid.modifier?
+    refute bid.contract?
+    assert_nil bid.level
+    assert_nil bid.suit
+  end
+
+  it "redouble is a valid bid" do
+    bid = Bridge::Bid.new("XX")
+    refute bid.pass?
+    refute bid.double?
+    assert bid.redouble?
+    assert bid.modifier?
+    refute bid.contract?
+    assert_nil bid.level
+    assert_nil bid.suit
+  end
+
+  it "1H is a valid bid" do
+    bid = Bridge::Bid.new("1H")
+    refute bid.pass?
+    refute bid.double?
+    refute bid.redouble?
+    refute bid.modifier?
+    assert bid.contract?
+    assert_equal "1", bid.level
+    assert_equal "H", bid.suit
+  end
+
+  it "7NT is a valid bid" do
+    bid = Bridge::Bid.new("7NT")
+    refute bid.pass?
+    refute bid.double?
+    refute bid.redouble?
+    refute bid.modifier?
+    assert bid.contract?
+    assert_equal "7", bid.level
+    assert_equal "NT", bid.suit
+  end
+
+  it "7NT is greater than 1C" do
+    assert Bridge::Bid.new("7NT") > Bridge::Bid.new("1C")
+    refute Bridge::Bid.new("7NT") < Bridge::Bid.new("1C")
+    refute Bridge::Bid.new("7NT") == Bridge::Bid.new("1C")
+  end
+
+  it "1S is greater than 1H" do
+    assert Bridge::Bid.new("1S") > Bridge::Bid.new("1H")
+    refute Bridge::Bid.new("1S") < Bridge::Bid.new("1H")
+    refute Bridge::Bid.new("1S") == Bridge::Bid.new("1H")
+  end
+
+  it "comparison of PASS and 1S raises an error" do
+    assert_raises(ArgumentError) do
+      Bridge::Bid.new("PASS") > Bridge::Bid.new("1S")
+    end
+  end
+
+  it "comparison of X and PASS raises an error" do
+    assert_raises(ArgumentError) do
+      Bridge::Bid.new("X") > Bridge::Bid.new("PASS")
+    end
+  end
+
+  it "PASS and XX are not equal" do
+    refute_equal Bridge::Bid.new("PASS"), Bridge::Bid.new("XX")
+  end
+
+  it "1S returns S trump" do
+    assert_equal "S", Bridge::Bid.new("1S").trump
+  end
+
+  it "5NT returns nil trump" do
+    assert_nil Bridge::Bid.new("5NT").trump
+  end
+
+  it "1H is a major bid" do
+    assert Bridge::Bid.new("1H").major?
+  end
+
+  it "5S is a major bid" do
+    assert Bridge::Bid.new("5S").major?
+  end
+
+  it "2C is a minor bid" do
+    assert Bridge::Bid.new("2C").minor?
+  end
+
+  it "6D is a minor bid" do
+    assert Bridge::Bid.new("6D").minor?
+  end
+
+  it "1NT is a nt bid" do
+    assert Bridge::Bid.new("1NT").nt?
+  end
+
+  it "6NT is a small slam" do
+    assert Bridge::Bid.new("6NT").small_slam?
+  end
+
+  it "7NT is a grand slam" do
+    assert Bridge::Bid.new("7NT").grand_slam?
+  end
+end