ofcp_scoring 0.0.2

data/spec/chinese_poker_hand_categorizer_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe "Hand Categorization" do
+  FakeHandOrganizer = Struct.new(:to_s) do
+    def organize(hand)
+      return ""
+    end
+  end
+
+  FakeOrganizedHand = Struct.new(
+    :two_cards_match?,
+    :two_different_cards_match?,
+    :three_cards_match?,
+    :four_cards_match?,
+    :all_suits_match?,
+    :ranks_in_order?,
+    :high_card_ace?,
+    :three_card_hand?
+  )
+
+  before(:each) do
+    @organizer = FakeHandOrganizer.new
+    @sut = OfcpScoring::HandCategorizer.new(@organizer)
+  end
+
+  context "Five Card Hands" do
+    it "should return an empty string if no hand is present" do
+      expect(@sut.categorize(nil)).to eq("")
+    end
+    it "should return a Pair when two cards match" do
+      hand = FakeOrganizedHand.new(:two_cards_match)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::Pair.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+    it "should return two Pair when two sets of two cards match" do
+      hand = FakeOrganizedHand.new(:two_cards_match, :two_different_cards_match)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::TwoPair.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+    it "should return Three Of a Kind when three cards match" do
+      hand = FakeOrganizedHand.new(false, false, :three_cards_match)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::ThreeOfAKind.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+    it "should return Four of a kind when four cards match" do
+      hand = FakeOrganizedHand.new(false, false, false, :four_cards_match)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::FourOfAKind.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+    it "should return Full House when three cards match and two cards match" do
+      hand = FakeOrganizedHand.new(:two_cards_match, false, :three_cards_match)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::FullHouse.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+    it "should return High Card when no cards match" do
+      hand = FakeOrganizedHand.new(false, false, false, false)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::HighCard.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+    it "should return OfcpScoring::Flush when suits all same" do
+      hand = FakeOrganizedHand.new(false, false, false, false, :all_suits_match)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::Flush.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+    it "should return Straight when all five cards are in sequential order" do
+      hand = FakeOrganizedHand.new(false, false, false, false, false, :ranks_in_order)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::Straight.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+    it "should return a StraightFlush when all five cards are in sequential order and all suits match" do
+      hand = FakeOrganizedHand.new(false, false, false, false, :all_suits_match, :ranks_in_order)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::StraightFlush.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+    it "should return a RoyalFlush when all five cards are in sequential order, all suits match and highest rank is an Ace" do
+      hand = FakeOrganizedHand.new(false, false, false, false, :all_suits_match, :ranks_in_order, :high_card_ace)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::RoyalFlush.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+  end
+  context "Three Card Hands" do
+    it "should never return a flush" do
+      hand = FakeOrganizedHand.new(false, false, false, false, :all_suits_match, :ranks_in_order, :high_card_ace, :three_card_hand)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::HighCard.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+    it "should never return a straight" do
+      hand = FakeOrganizedHand.new(false, false, false, false, false, :ranks_in_order, :high_card_ace, :three_card_hand)
+      @organizer.stub(:organize).and_return(hand)
+      OfcpScoring::HighCard.should_receive(:new).with(hand)
+      @sut.categorize(hand)
+    end
+  end
+
+end
+
+
+describe "Integration" do
+  it "should categorized unorganized hands correctly" do
+    sut = OfcpScoring::HandCategorizer.new
+    # expect(sut.categorize(%w(Ah 4s Qs))).to be_a(OfcpScoring::HighCard)
+    # expect(sut.categorize(%w(2h 3h 4h 5h 7h))).to be_a(OfcpScoring::Flush)
+    expect(sut.categorize(%w(Kh Kd Ks 9c 9s))).to be_a(OfcpScoring::FullHouse)
+  end
+end

data/spec/chinese_poker_hand_evaluator_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+ScorableHand = Struct.new(:front,:middle, :back, :misset?)
+
+
+describe "Evaluator" do
+  before(:each) do
+    @hand_one = %w(Ah Ks Qs 10s 10d 7d 6c 8h Qc Qd Ad 2c 4d)
+    @hand_two = %w(9h 9c Qs 10s 10d 7d 6c 8h Qc Qd Ad 2c 4d)
+    @sut = OfcpScoring::HandEvaluator.new(FakeFactory.new, FakeRoyaltyCalculator.new)
+  end
+  it "should evaluate the front hands" do
+    expect(@sut.evaluate(ScorableHand.new(1,0,0), ScorableHand.new(0,1,1))).to eq([1,2])
+  end
+  it "should evaluate the middle hands" do
+    expect(@sut.evaluate(ScorableHand.new(1,0,0), ScorableHand.new(0,1,0))).to eq([1,1])
+  end
+  it "should evaluate the back hands" do
+    expect(@sut.evaluate(ScorableHand.new(1,1,0), ScorableHand.new(0,0,1))).to eq([2,1])
+  end
+  it "should add a scoop bonus" do
+    expect(@sut.evaluate(ScorableHand.new(1,1,1), ScorableHand.new(0,0,0))).to eq([6,0])
+  end
+  it "should give no points for misset hands" do
+    expect(@sut.evaluate(ScorableHand.new(1,1,1, true), ScorableHand.new(0,0,0))).to eq([0,6])
+    expect(@sut.evaluate(ScorableHand.new(1,1,1), ScorableHand.new(0,0,0, true))).to eq([6,0])
+  end
+end
+
+describe "Royalties Calculation" do
+  it "should add royalties for a hand when it wins" do
+    royalty_calc = double(OfcpScoring::RoyaltiesCalculator, :calculate_bonus => 0)
+    sut = OfcpScoring::HandEvaluator.new(FakeFactory.new, royalty_calc)
+    royalty_calc.should_receive(:calculate_bonus).once.with(1, :front)
+    royalty_calc.should_receive(:calculate_bonus).once.with(1, :middle)
+    royalty_calc.should_receive(:calculate_bonus).once.with(1, :back)
+    sut.evaluate(ScorableHand.new(1,0,1), ScorableHand.new(0,1,0))
+  end
+
+  it "should add the royalties for the first hand to its score" do
+    royalty_calc = OfcpScoring::RoyaltiesCalculator.new
+    royalty_calc.stub(:calculate_bonus).and_return(10)
+    sut = OfcpScoring::HandEvaluator.new(FakeFactory.new, royalty_calc)
+    expect(sut.evaluate(ScorableHand.new(1,0,1), ScorableHand.new(0,1,0))).to eq([22,11])
+  end
+
+end
+
+describe "Integration" do
+  it "should score front, middle and back hands" do
+    @hand_one = %w(Ah Ks Qs 8s 8d 7d 6c 4h Jc Jd Ad 2c 4d)
+    @hand_two = %w(9h 6c Qs 10s 10d 7d 6c 8h Qc Qd Ad 2c 4d)
+
+    sut = OfcpScoring::HandEvaluator.new
+    expect(sut.evaluate(@hand_one, @hand_two)).to eq([1,2])
+  end
+end
+
+class FakeFactory
+  def build(hand)
+      hand
+  end
+end
+
+class FakeRoyaltyCalculator
+  def calculate_bonus(hand, position)
+      0
+  end
+end

data/spec/chinese_poker_hand_organizer_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe "Hand Organizer" do
+  it "should return am empty string if no hand is present" do
+    sut = OfcpScoring::HandOrganizer.new
+    expect(sut.organize(nil)).to eq("")
+  end
+end
+
+describe "Integration" do
+  it "should organize hands" do
+    hand = %w(Qc Qd Ad 2c 4d)
+    sut = OfcpScoring::HandOrganizer.new
+    organized = sut.organize(hand)
+    expect(organized.two_cards_match?).to be
+    expect(organized.two_different_cards_match?).to_not be
+    expect(organized.ranks).to eq([1,2,4,12,12])
+  end
+end

data/spec/chinese_poker_hand_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "Chinese Poker Hands" do
+  it "should know when it is misset" do
+    sut = OfcpScoring::ChinesePokerHand.new({
+      :front => OfcpScoring::ThreeOfAKind.new({:ranks => [9,9,9]}),
+      :middle => OfcpScoring::Pair.new({:ranks => [2,3,5,8,8]}),
+      :back => OfcpScoring::HighCard.new({:ranks => [2,3,4,5,7]})
+    })
+
+    expect(sut.misset?).to be
+  end
+
+  it "should know when it is not misset" do
+    sut = OfcpScoring::ChinesePokerHand.new({
+      :back => OfcpScoring::ThreeOfAKind.new({:ranks => [9,9,9,5,7]}),
+      :middle => OfcpScoring::Pair.new({:ranks => [2,3,5,8,8]}),
+      :front => OfcpScoring::HighCard.new({:ranks => [2,3,4]})
+    })
+
+    expect(sut.misset?).to_not be
+  end
+end

data/spec/chinese_poker_scoring_engine_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "Chinese Poker Scoring Engine" do
+  before(:each) do
+    @sut = OfcpScoring::ScoringEngine.new
+    @hand_one = %w(Ah Ks Qs 10s 10d 7d 6c 8h Qc Qd Ad 2c 4d)
+    @hand_two = %w(9h 9c Qs 10s 10d 7d 6c 8h Qc Qd Ad 2c 4d)
+  end
+  it "should return no score for nil hands" do
+    expect(@sut.score(nil, nil)).to eq([0,0])
+  end
+  it "should return no score for one nil hand" do
+    expect(@sut.score(nil, 0)).to eq([0,0])
+  end
+  it "should use a hand evaluator to compare and score the hands" do
+    evaluator = double(OfcpScoring::HandEvaluator, :evaluate => [2,1])
+    evaluator.should_receive(:evaluate).with(@hand_one, @hand_two)
+
+    sut = OfcpScoring::ScoringEngine.new(evaluator)
+    sut.score(@hand_one, @hand_two)
+  end
+end
+

data/spec/hand_factory_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "Building Hands" do
+  it "should build Chinese Poker Hands" do
+    sut = OfcpScoring::HandFactory.new(FakeCategorizer.new)
+    OfcpScoring::ChinesePokerHand.should_receive(:new)
+    sut.build(%w())
+  end
+  it "should use an categorizer to categorize the hand" do
+    categorizer = double(OfcpScoring::HandCategorizer, :categorize => {})
+    categorizer.should_receive(:categorize).with(%w())
+    sut = OfcpScoring::HandFactory.new(categorizer)
+    sut.build(%w())
+  end
+end
+
+
+class FakeCategorizer
+  def categorize(hand)
+    hand
+  end
+end

data/spec/organized_hand_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe "Organized Hands" do
+end

data/spec/ranked_hand_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+class HandWithRankings
+  def initialize(ranks)
+    @ranks = ranks
+  end
+  def ranks
+    @ranks
+  end
+  def grouped_ranks
+    @ranks.group_by{|c| c}
+  end
+end
+
+describe "Ranked Hands" do
+
+  it "should rank RoyalFlushes above Straight Flushes" do
+    royal_flush = OfcpScoring::RoyalFlush.new
+    straight_flush = OfcpScoring::StraightFlush.new
+
+    expect(royal_flush > straight_flush).to be
+  end
+
+  it "should rank Straight Flushes above Four of a Kind" do
+    straight_flush = OfcpScoring::StraightFlush.new
+    four_of_a_kind = OfcpScoring::FourOfAKind.new
+
+    expect(straight_flush > four_of_a_kind).to be
+  end
+
+  it "should rank a Full House over a Pair" do
+    full_house = OfcpScoring::FullHouse.new
+    pair = OfcpScoring::Pair.new
+
+    expect(full_house > pair).to be
+  end
+
+  it "should rank a Flush over a Pair" do
+    flush = OfcpScoring::Flush.new
+    pair = OfcpScoring::Pair.new
+
+    expect(pair < flush).to be
+  end
+
+  it "should rank TwoPair over a Pair" do
+    two_pair = OfcpScoring::TwoPair.new
+    pair = OfcpScoring::Pair.new
+
+    expect(pair < two_pair).to be
+  end
+
+  context "Breaking Ties" do
+    context "When comparing High Card Hands" do
+      it "the higest card should be greater" do
+        ace_high  = OfcpScoring::HighCard.new(HandWithRankings.new([6,7,8,9,14]))
+        king_high = OfcpScoring::HighCard.new(HandWithRankings.new([6,7,8,9,13]))
+        expect(ace_high > king_high).to be
+        expect(king_high < ace_high).to be
+      end
+    end
+    context "When comparing Pairs" do
+      it "should compare the value of the paired card" do
+        eights  = OfcpScoring::Pair.new(HandWithRankings.new([6,7,8,8,13]))
+        sixes = OfcpScoring::Pair.new(HandWithRankings.new([6,6,8,9,14]))
+        expect(eights > sixes).to be
+        expect(sixes < eights).to be
+      end
+      it "should break ties of pairs by comparing the rest of the cards" do
+        with_six  = OfcpScoring::Pair.new(HandWithRankings.new([6,8,8,13,14]))
+        with_five = OfcpScoring::Pair.new(HandWithRankings.new([5,8,8,13,14]))
+        expect(with_six > with_five).to be
+        expect(with_five < with_six).to be
+      end
+    end
+    context "When comparing TwoPair Hands" do
+      it "should compare the value of the highest paired card of the highest pair" do
+        eights_and_sixes = OfcpScoring::TwoPair.new(HandWithRankings.new([6,6,8,8,14]))
+        fives_and_fours  = OfcpScoring::TwoPair.new(HandWithRankings.new([4,4,5,5,14]))
+        expect(eights_and_sixes > fives_and_fours).to be
+        expect(fives_and_fours < eights_and_sixes).to be
+      end
+      it "should first break ties of pairs by comparing the lower pair" do
+        eights_and_sixes = OfcpScoring::TwoPair.new(HandWithRankings.new([6,6,8,8,14]))
+        eights_and_fours  = OfcpScoring::TwoPair.new(HandWithRankings.new([4,4,8,8,14]))
+        expect(eights_and_sixes > eights_and_fours).to be
+        expect(eights_and_fours < eights_and_sixes).to be
+      end
+      it "should lastly break ties of pairs by comparing the other cards" do
+        with_ace  = OfcpScoring::TwoPair.new(HandWithRankings.new([6,6,8,8,14]))
+        with_jack = OfcpScoring::TwoPair.new(HandWithRankings.new([6,6,8,8,11]))
+        expect(with_ace > with_jack).to be
+        expect(with_jack < with_ace).to be
+      end
+    end
+    context "When comparing Three of a Kind Hands" do
+      it "should compare the value of the three cards" do
+        eights  = OfcpScoring::ThreeOfAKind.new(HandWithRankings.new([6,8,8,8,13]))
+        sixes = OfcpScoring::ThreeOfAKind.new(HandWithRankings.new([6,6,6,9,14]))
+        expect(eights > sixes).to be
+        expect(sixes < eights).to be
+      end
+    end
+    context "When comparing Full Houses" do
+      it "should use the value of the trip cards" do
+        eights  = OfcpScoring::ThreeOfAKind.new(HandWithRankings.new([5,8,8,8,5]))
+        sixes = OfcpScoring::ThreeOfAKind.new(HandWithRankings.new([6,6,6,9,9]))
+        expect(eights > sixes).to be
+        expect(sixes < eights).to be
+      end
+    end
+    context "When comparing Four of a Kind Hands" do
+      it "should compare the value of the four cards" do
+        eights  = OfcpScoring::FourOfAKind.new(HandWithRankings.new([8,8,8,8,13]))
+        sixes = OfcpScoring::FourOfAKind.new(HandWithRankings.new([6,6,6,6,14]))
+        expect(eights > sixes).to be
+        expect(sixes < eights).to be
+      end
+    end
+    context "When comparing OfcpScoring::Flushes" do
+      it "should compare the highest card" do
+        ten_high  = OfcpScoring::Flush.new(HandWithRankings.new([2,3,4,5,10]))
+        eight_high = OfcpScoring::Flush.new(HandWithRankings.new([2,3,4,5,8]))
+        expect(ten_high > eight_high).to be
+        expect(eight_high < ten_high).to be
+      end
+    end
+    context "When comparing straights" do
+      it "should use the highest card when an ace is not involved" do
+        ten_high  = OfcpScoring::Straight.new(HandWithRankings.new([2,3,4,5,10]))
+        eight_high = OfcpScoring::Straight.new(HandWithRankings.new([2,3,4,5,8]))
+        expect(ten_high > eight_high).to be
+        expect(eight_high < ten_high).to be
+      end
+      context "When there is an ace" do
+        it "should rank broadway straights above king high straights" do
+          broadway  = OfcpScoring::Straight.new(HandWithRankings.new([10,11,12,13,14]))
+          king_high = OfcpScoring::Straight.new(HandWithRankings.new([9,10,11,12,13]))
+          expect(broadway > king_high).to be
+          expect(king_high < broadway).to be
+        end
+        it "should rank six high straights above wheel straights" do
+          six_high  = OfcpScoring::Straight.new(HandWithRankings.new([2,3,4,5,6]))
+          wheel = OfcpScoring::Straight.new(HandWithRankings.new([14,2,3,4,5]))
+          expect(six_high > wheel).to be
+          expect(wheel < six_high).to be
+        end
+      end
+    end
+    context "When comparing straight flushes" do
+      it "should use the highest card" do
+        ten_high  = OfcpScoring::StraightFlush.new(HandWithRankings.new([2,3,4,5,10]))
+        eight_high = OfcpScoring::StraightFlush.new(HandWithRankings.new([2,3,4,5,8]))
+        expect(ten_high > eight_high).to be
+        expect(eight_high < ten_high).to be
+      end
+    end
+  end
+
+end

data/spec/royalties_calculator_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+FakeHand = Struct.new(:class, :ranks) do
+  def rank_name
+    self.class
+  end
+end
+
+describe "Royalties Calculations" do
+  before(:each) do
+    @sut = OfcpScoring::RoyaltiesCalculator.new
+  end
+  describe "For Front Hands" do
+    it "should give an extra point for a pair of sixes" do
+      expect(@sut.calculate_bonus(FakeHand.new("Pair", [6]), :front)).to eq(1)
+    end
+    it "should give two extra points for a pair of sevens" do
+      expect(@sut.calculate_bonus(FakeHand.new("Pair", [7]), :front)).to eq(2)
+    end
+    it "should give three extra points for a pair of eights" do
+      expect(@sut.calculate_bonus(FakeHand.new("Pair", [8]), :front)).to eq(3)
+    end
+    it "should give 9 extra points for a pair of Aces" do
+      expect(@sut.calculate_bonus(FakeHand.new("Pair", [14]), :front)).to eq(9)
+    end
+    it "should give no extra points for high card hands" do
+      expect(@sut.calculate_bonus(FakeHand.new("HighCard", [14]), :front)).to eq(0)
+    end
+  end
+
+  describe "For Middle Hands" do
+    it "should not give any bonus for a pair" do
+      expect(@sut.calculate_bonus(FakeHand.new("Pair", [14]), :middle)).to eq(0)
+    end
+    it "should give 20 extra points for a straight flush in the middle" do
+      expect(@sut.calculate_bonus(FakeHand.new("StraightFlush"), :middle)).to eq(20)
+    end
+    it "should give 16 extra points for Quads in the middle" do
+      expect(@sut.calculate_bonus(FakeHand.new("FourOfAKind"), :middle)).to eq(16)
+    end
+    it "should give 12 extra points for a full house in the middle" do
+      expect(@sut.calculate_bonus(FakeHand.new("FullHouse"), :middle)).to eq(12)
+    end
+    it "should give 8 extra points for a flush in the middle" do
+      expect(@sut.calculate_bonus(FakeHand.new("Flush"), :middle)).to eq(8)
+    end
+    it "should give 12 extra points for a straight in the middle" do
+      expect(@sut.calculate_bonus(FakeHand.new("Straight"), :middle)).to eq(4)
+    end
+  end
+  describe "For Back Hands" do
+    it "should not give any bonus for a pair" do
+      expect(@sut.calculate_bonus(FakeHand.new("Pair", [14]), :back)).to eq(0)
+    end
+    it "should give 20 extra points for a royal flush in the back" do
+      expect(@sut.calculate_bonus(FakeHand.new("RoyalFlush"), :back)).to eq(20)
+    end
+    it "should give 10 extra points for a straight flush in the back" do
+      expect(@sut.calculate_bonus(FakeHand.new("StraightFlush"), :back)).to eq(10)
+    end
+    it "should give 8 extra points for Quads in the back" do
+      expect(@sut.calculate_bonus(FakeHand.new("FourOfAKind"), :back)).to eq(8)
+    end
+    it "should give 6 extra points for a full house in the back" do
+      expect(@sut.calculate_bonus(FakeHand.new("FullHouse"), :back)).to eq(6)
+    end
+    it "should give 4 extra points for a flush in the back" do
+      expect(@sut.calculate_bonus(FakeHand.new("Flush"), :back)).to eq(4)
+    end
+    it "should give 2 extra points for a straight in the back" do
+      expect(@sut.calculate_bonus(FakeHand.new("Straight"), :back)).to eq(2)
+    end
+  end
+end
+
+# With Royalties you receive the following points for Back hands:
+
+# 20 for a Royal
+# 10 for StraightFlush
+# 8 for Quads
+# 6 for a Full House
+# 4 for a OfcpScoring::Flush
+# 2 for a Straight
+# (Some players might play 10 for Quads, 15 for a StraightFlush, and 25 for a Royal, so it is wise to agree the Royalites system beforehand just in case)
+
+# You receive the following points for Middle hands:
+
+# 20 for StraightFlush
+# 16 for Quads
+# 2 for a Full House
+# 8 for a OfcpScoring::Flush
+# 4 for a Straight
+# You receive the following points for Front hands (the 3 card hand):
+
+# Pair of Aces: 9 points
+# Pair of Kings: 8 points
+# Pair of Queens: 7 points
+# Pair of Jacks: 6 points
+# Pair of Tens: 5 points
+# Pair of Nines: 4 points
+# Pair of Eights: 3 points
+# Pair of Sevens: 2 points
+# Paid of Sixes: 1 point

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+rescue LoadError => e
+
+end
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'ofcp_scoring.rb')