skating-system 0.1.1

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Laurie Young
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,200 @@
+Skating System
+--------------
+
+Provides an implementation of the skating system used for scoring dance comeptitions, as well as a few other types of competition.
+
+Usage
+------
+
+First create a hash of the judges marks
+@couples_marks = { @entree1=>{@judge1=>1, @judge2=>1, @judge3=>3 },
+                   @entree2=>{@judge1=>2, @judge2=>3, @judge3=>2 },
+                   @entree3=>{@judge1=>3, @judge2=>2, @judge3=>1 }} 
+
+
+Create a new PerformanceResults object, and then call its score method
+@performance_resuts = SkatingSystem::PerformanceResults.new	
+@performance_resuts.score(@couples_marks)
+Then you can access the ranking for the couples via
+@performance_resuts.ranking.should be(@ranking)
+
+
+The skating system is as follows:
+
+
+ ********* The Marking of Adjudicators' Cards
+   1.
+      In all rounds each judge must vote for the number of couples
+   demanded by the Chairman of Adjudicators. 
+
+   2.
+      In the Final round each judge shall place all the competing
+   couples in order of merit in each of the dances. 
+
+   3.
+      In the Final round the judge shall mark his first couple 1, his
+   second couple 2, his third 3, and so on in each of the dances. 
+
+   4.
+      A judge must not tie couples for any place in the Final of any dance.
+
+      Note:
+
+            Number of Couples to Dance in a Final
+
+         1.            
+           In the Final round the open system of marking shall be used. 
+
+         2.
+            When judges are instructed to select six couples for a
+            Final and six couples are clearly chosen only that number
+            shall dance. The same procedure would be observed if the 
+            Chairman's instructions were for any other number. 
+
+         3.
+            If it is intended that six couples shall dance in a Final
+            and through a tie more couples qualify for consideration
+            the number to dance shall be decided by the Chairman. The
+            same procedure would be observed if it is intended to have
+            a Final of any other number.  
+
+********* The Allocation of Positions in Each Dance
+   5.
+      The winner of a particular dance is the couple who is placed
+      first by an absolute majority of judges; second, the couple who
+      is placed second or higher by an absolute majority. The
+      remaining positions are allocated in a similar way. 
+
+      If More that One Couple have a Majority for the Same Position
+
+   6.
+      The couple with the largest majority shall be allocated the
+      position under review, and the couple with the next largest
+      majority, the following position. 
+
+      Note:
+
+      If the position under review is the "2nd" and two couples have a
+      majority of "2nd and higher" places, the couple with the larger
+      majority shall be placed "2nd" and the other couple "3rd". 
+
+      We now examine the remaining competitors' markings, and the
+      couple with the largest majority of "3rd and higher" places
+      shall be allocated the next position, which in this example, is
+      the "4th". 
+
+      If none of the remaining couples has a majority of "3rd and
+      higher" places, then include the "4th" places (and, if
+      necessary, lower places). 
+
+********* If Two or More Couples have an Equal Majority for the Same Position
+   7.
+      a) If such majorities are equal, then the lowest total of marks
+      given by those judges who form the majority, shall determine the
+      allocation of the position under review. 
+
+      Note:
+
+      If the position under review is the "2nd" and two couples have a
+      similar majority of "2nd and higher" places, the couple with the
+      lower total of marks given by those judges who form the
+      majority, shall be allocated the "2nd" position and the other
+      couple the "3rd". 
+
+      b) If the totals of the marks are equal, then the next lower
+      place (or places, if necessary), in respect of the particular
+      couples concerned, must be included. 
+
+      Note:
+
+      It should be noted that only the couples who have a majority for
+      the position under review (say, for example, the "2nd" position)
+      must be considered at this stage, and only their "3rd" places
+      (and, if necessary, lower places) should be referred to, until
+      the "2nd" position has been allocated. 
+
+      A definite result will eventually be obtained unless the
+      remaining markings are exactly the same, and should the latter
+      be the case, there will, of course, be a tie for "2nd"
+      position. If two couples were concerned, they would be allocated
+      "2 1/2" each. 
+
+
+********* If No Couple receives a Majority for the Position Under Review
+   8.
+      If no couple receives a majority of "Firsts" then the winner is
+      the couple who are placed "2nd and higher" by a majority of
+      judges. 
+
+      If no couple receives a majority of "1st" and "2nd" places, then
+      the "3rd" places (and if necessary, lower places) must be
+      included. (Subject to Rules 6 and 7). 
+
+      The "2nd" and other places should be calculated in a similar
+      way.
+
+********* Compilation of the Final Summary
+   9.
+      When all the dances have been concluded, the order ascertained
+      for each dance shall be carried to another sheet, showing the
+      position achieved by each couple in each dance. The first in
+      each dance shall be given one mark, the second two, and so
+      on. These place marks shall be added up and the couple with the
+      lowest aggregate shall be the winner. 
+
+
+********* If there is a Tie for a Place in the Final Summary
+  10.
+      a) If this results in a tie for first place, the winner shall be
+      the couple who has actually won the greater number of dances. 
+
+      b) If there is a tie for the "2nd" place, the "2nd" prize shall
+      be awarded to the couple who has obtained "2nd and higher" in
+      the greatest number of dances. If the couples have obtained the
+      same number of "2nd and higher" place marks, then add the "2nd
+      and higher" place marks together and the couple with the lowest
+      total should be awarded second prize. 
+
+      Note:
+
+      If more than two couples tie for second place, the second prize
+      shall be awarded to the couple who has obtained the most "2nd
+      and higher" place marks. Still only considering the remaining
+      "tied" couples, the "3rd" prize is awarded to the couple who has
+      won the most "3rd and higher" place marks. 
+
+      c) If there is a tie for any remaining places they shall be
+      decided on similar principles. 
+
+  11.
+
+      If after applying Rules 9 and 10 this still results in a tie,
+      then treat the judges' marks of the "tied" couples over all
+      dances, as for an individual dance (Rules 5 to 8). If this still
+      results in a tie, there shall be at the discretion of the
+      organizers of the competition, either a re-dance or the prizes
+      for the places under review shall be divided. 
+
+      a) If the tie is for first place, a majority of "1st" marks to
+      the credit of either of the "tied" couples (4 dances-5
+      judges-majority 11) would win. If neither of the "tied" couples
+      receive a majority of "firsts" see Rule 8. 
+
+      b) If the tie is for second place, a majority of "2nd and
+      higher" marks to the credit of either of the "tied" couples
+      would be necessary. If neither of the "tied" couples obtain a
+      majority of "2nd and higher" marks see Rule 8. 
+
+      c) The "3rd" or any other "tied" places should be decided on similar principles.
+
+      d) If 3 (or more) couples tie for a place under Rule 10 (say,
+      2nd place) Rule 11 is applied to all couples concerned in the
+      tie, and the best couple is awarded the "2nd" place. Rule 10 is
+      now applied to the remaining "tied" couples for consideration of
+      the place now under review, which is the "3rd". However, if they
+      now tie for "3rd" under Rule 10, then Rule 11 is again applied
+      to these "tied" couples, commencing this time with the "3rd and
+      higher" judges's marks in the individual dances. 
+
+It is distributed under the MIT Licence, see licence.txt for the details
+

data/README.rdoc

@@ -0,0 +1,17 @@
+= skating-system
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Wildfalcon. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "skating-system"
+    gem.summary = "Dancesport skating system implementation"
+    gem.description = %Q{Convert judges scores from a dance-competition into results}
+    gem.email = "laurie@wildfalcon.com"
+    gem.homepage = "http://github.com/wildfalcon/skating-system"
+    gem.authors = ["Wildfalcon"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "foobar #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/skating_system.rb

@@ -0,0 +1,6 @@
+require 'skating_system/performance_results'
+require 'skating_system/ranking'
+require 'skating_system/scorer'
+
+module SkatingSystem
+end

data/lib/skating_system/performance_results.rb

@@ -0,0 +1,114 @@
+module SkatingSystem
+  class PerformanceResults
+    
+    def score(marks)
+      @marks = marks
+      @majority = (@marks[@marks.keys.first].size/2).ceil
+      
+      tally_marks
+
+      compute_results
+      
+      @marks.each do |entree, marks|
+        @marks[entree].merge!(@tally[entree])
+        @marks[entree].merge!(@results[entree])
+      end
+    end
+    
+    #Generate the ranking table for this performance
+    def ranking
+      return @ranking if @ranking
+      @ranking =SkatingSystem::Ranking.new
+      @marks.each do |entree, data|
+         @ranking.add(data[:result], entree)
+      end
+      @ranking
+    end
+    
+    def [](key)
+      @marks[key]
+    end
+
+    
+    
+    private
+    def sum_marks(entree, position)
+      sum=0
+      @marks[entree].each do |judge, place|
+        sum += place if place <= position 
+      end
+      sum
+    end
+    
+    def compute_results
+      @results={ }
+      @marks.each do |entree, marks|
+        @results[entree] ||= { }
+      end
+      
+      @next_result_to_compute = 1
+      
+      1.upto(@marks.size) do |place|  
+        
+        
+        sorted_candidate = candidates(place).sort do |entree1, entree2| 
+          comparator = @tally[entree2][place] <=> @tally[entree1][place] 
+          if comparator==0
+            comparator = sum_marks(entree1, place) <=> sum_marks(entree2, place) 
+          end 
+          comparator
+        end
+        
+        sorted_candidate.each do |entree|
+          @results[entree][:result]=@next_result_to_compute
+          @next_result_to_compute += 1
+        end
+      end
+    end
+    
+    #Computes an array of entrees that are candidates for this position 
+    def candidates(place)
+      candidates = []
+      @tally.each do |entree, places|
+        unless @results[entree][:result]
+          candidates << entree if places[place] > @majority
+        end
+      end
+      candidates
+    end
+    
+    #Tallys the number of judges who marked each entree in each place or heigher
+    # and writes the results to @tally
+    # eg given the results
+    #    A  B  C 
+    # 1  1  1  3 
+    # 2  2  3  2 
+    # 3  3  2  3 
+    # it assigns the tally
+    #    1  2  3
+    # 1  2  2  3
+    # 2  0  2  3
+    # 3  0  1  3
+    def tally_marks
+      @tally={ }
+      @marks.each do |entree, marks|
+        @tally[entree] ||= { }
+        1.upto(@marks.size) do |place|
+          @tally[entree][place] = 0
+        end
+      end
+      
+      @marks.each do |entree, marks|
+        marks.each do |judge, placing|
+          placing.upto(@marks.size) do |place|
+            @tally[entree][place] += 1
+          end
+        end
+      end
+      
+    end
+    
+  end
+end
+
+

data/lib/skating_system/ranking.rb

@@ -0,0 +1,34 @@
+module SkatingSystem
+  class Ranking
+    attr_accessor :rank_table
+    
+    def initialize
+      @rank_table={ }
+    end
+    
+    #Ads a new result to this ranking
+    def add(place, competitor)
+      raise "too many couples in higher placings" if places_higher_than(place) >= place
+      
+      competitors = @rank_table[place] || []
+      competitors  << competitor
+      @rank_table[place] = competitors
+    end
+
+    def place_for(competitor)
+      rank_table.each do |key, value|
+        return key if value.include?(competitor)
+      end
+      raise "Unkown competitor"
+    end
+
+    def places_higher_than(place)
+      higher_placings = 0
+      1.upto(place-1) do |p|
+        higher_placings +=  @rank_table[p] ? @rank_table[p].size : 0
+      end
+      return higher_placings
+    end
+
+  end
+end

data/lib/skating_system/scorer.rb

@@ -0,0 +1,14 @@
+module SkatingSystem
+  class Scorer
+    def score(scorable)
+      score_performance(scorable) if scorable.respond_to?(:couples_marks)
+    end
+    
+    def score_performance(performance)
+      results = PerformanceResults.new
+      results.score(performance.couples_marks)    
+      results
+    end
+    
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--format
+progress
+--loadby
+mtime
+--reverse

data/spec/spec/performance_results_spec.rb

@@ -0,0 +1,107 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+
+describe SkatingSystem::PerformanceResults, "tallying the marks" do
+  before(:all) do
+    @performance_resuts = SkatingSystem::PerformanceResults.new
+    
+    @judge1 = mock("Judge")
+    @judge2 = mock("Judge")
+    @judge3 = mock("Judge")
+    
+    @entree1 = mock("Entree")
+    @entree2 = mock("Entree")
+    @entree3 = mock("Entree")
+    
+    #    A  B  C     1 2 3
+    # 1  1  1  3     2 2 3    1
+    # 2  2  3  2     0 2 3    2
+    # 3  3  2  3     0 1 3    3
+    @couples_marks = { @entree1=>{@judge1=>1, @judge2=>1, @judge3=>3 },
+      @entree2=>{@judge1=>2, @judge2=>3, @judge3=>2 },
+      @entree3=>{@judge1=>3, @judge2=>2, @judge3=>3 }} 
+    
+    @performance_resuts.score(@couples_marks)
+  end
+  
+  it "should know how many first places entree1 got" do
+    @performance_resuts[@entree1][1].should be(2)
+  end
+  
+  it "should know how many first places entree2 got" do
+    @performance_resuts[@entree2][1].should be(0)
+  end
+
+  it "should know how many first places entree3 got" do
+    @performance_resuts[@entree3][1].should be(0)
+  end
+  
+  it "should know how many 2nd or better places entree1 got" do
+    @performance_resuts[@entree1][2].should be(2)
+  end
+
+  it "should know how many 2nd or better places entree2 got" do
+    @performance_resuts[@entree2][2].should be(2)
+  end
+
+  it "should know how many 2nd or better places entree3 got" do
+    @performance_resuts[@entree3][2].should be(1)
+  end
+
+  it "should know how many 3rd or better places entree1 got" do
+    @performance_resuts[@entree1][3].should be(3)
+  end
+
+  it "should know how many 3rd or better places entree2 got" do
+    @performance_resuts[@entree2][3].should be(3)
+  end
+
+  it "should know how many 3rd or better places entree3 got" do
+    @performance_resuts[@entree3][3].should be(3)
+  end
+end
+
+describe SkatingSystem::PerformanceResults, "getting the rankings" do
+  before(:each) do
+    @performance_resuts = SkatingSystem::PerformanceResults.new
+    
+    @judge1 = mock("Judge")
+    @judge2 = mock("Judge")
+    @judge3 = mock("Judge")
+    
+    @entree1 = mock("Entree")
+    @entree2 = mock("Entree")
+    @entree3 = mock("Entree")
+    
+    #    A  B  C     1 2 3
+    # 1  1  1  3     2 2 3    1
+    # 2  2  3  2     0 2 3    2
+    # 3  3  2  3     0 1 3    3
+    @couples_marks = { @entree1=>{@judge1=>1, @judge2=>1, @judge3=>3 },
+      @entree2=>{@judge1=>2, @judge2=>3, @judge3=>2 },
+      @entree3=>{@judge1=>3, @judge2=>2, @judge3=>3 }} 
+
+    SkatingSystem::Ranking.stub!(:new).and_return(@ranking = mock(SkatingSystem::Ranking))
+    @ranking.stub!(:add) 
+
+              @performance_resuts.score(@couples_marks)
+  end
+
+  it "should return a Ranking when asked for one" do
+    @performance_resuts.ranking.should be(@ranking)
+  end
+
+  it "should add couple 1 to the ranking in first place" do
+    @ranking.should_receive(:add).with(1, @entree1)
+    @performance_resuts.ranking
+  end
+
+  it "should add couple 2 to the ranking in second place" do
+    @ranking.should_receive(:add).with(2, @entree2)
+    @performance_resuts.ranking
+  end
+
+  it "should add couple 3 to the ranking in third place" do
+    @ranking.should_receive(:add).with(3, @entree3)
+    @performance_resuts.ranking
+  end
+end

data/spec/spec/ranking_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe SkatingSystem::Ranking do
+  before(:each) do
+    @ranking = SkatingSyatem::Ranking.new
+  end
+end
+
+
+describe SkatingSystem::Ranking, "adding new results" do
+  
+  before(:each) do
+    @ranking = SkatingSystem::Ranking.new
+  end
+    
+  it "should put an entry in first place when they are entered in first place" do
+    entree = mock("Entree")
+    @ranking.add(1, entree)
+    @ranking.place_for(entree).should be(1)
+  end
+  
+  it "should put both entries in first place when entered in first place, even if there is already a first place" do
+    entree1 = mock("Entree")
+    entree2 = mock("Entree")
+    @ranking.add(1, entree1)
+    @ranking.add(1, entree2)
+    @ranking.place_for(entree1).should be(1)
+    @ranking.place_for(entree2).should be(1)
+  end
+  
+  it "should put an entry in second place when entred in second place" do
+    entree = mock("Entree")
+    @ranking.add(2, entree)
+    @ranking.place_for(entree).should be(2)
+  end
+
+  it "should put both in second place when netered in second place, even if there is already a second place" do
+    entree1 = mock("Entree")
+    entree2 = mock("Entree")
+    @ranking.add(2, entree1)
+    @ranking.add(2, entree2)
+    @ranking.place_for(entree1).should be(2)
+    @ranking.place_for(entree2).should be(2)
+  end
+  
+  it "should not allow an entry in second place if there are two first places" do       
+    entree1 = mock("Entree")
+    entree2 = mock("Entree")
+    entree3 = mock("Entree")
+    @ranking.add(1, entree1)
+    @ranking.add(1, entree2)
+    lambda{ @ranking.add(2, entree3)}.should raise_error
+  end
+
+  it "should reise an exception if asked about an unknown entree" do
+    lambda{ @ranking.place_for(mock("Entree"))}.should raise_error
+  end
+
+  
+  
+end

data/spec/spec/scorer_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe "scoring a final performance" do
+  before(:each) do
+    @scorer = SkatingSystem::Scorer.new
+    @performance = mock("Performance")
+    @couples_marks = {:key=>:value }
+    SkatingSystem::PerformanceResults.stub!(:new).and_return(@pr=mock(SkatingSystem::PerformanceResults, :score=>nil))
+    @performance.stub!(:couples_marks).and_return(@couples_marks)
+  end
+  
+  it "should check if the scorable thing respondes to :couples_marks" do
+    @performance.should_receive(:respond_to?).with(:couples_marks).and_return(true)
+    @scorer.score(@performance)
+  end
+  
+  it "should delegate to score_performance" do
+    @scorer.should_receive(:score_performance).with(@performance)
+    @scorer.score(@performance)
+  end
+  
+  it "should return a the new Performance" do
+    @scorer.score_performance(@performance).should be(@pr)
+  end
+  
+  it "should ask the PerformanceResults to score itself" do
+    @pr.should_receive(:score).with(@couples_marks)
+    @scorer.score(@performance)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+dir = File.dirname(__FILE__)
+lib_path = File.expand_path("#{dir}/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+require 'rubygems'
+require 'skating_system'
+require 'ruby-debug'
+
+Spec::Runner.configure do |config|
+
+end

data/stories/all.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), *%w[helper])
+
+%w[final_performance].each do |dir|
+  require File.join(File.dirname(__FILE__), "#{dir}/stories")
+end

data/stories/final_performance/final_performance

@@ -0,0 +1,69 @@
+Story: Scrutineering a final round dance
+
+  As a scrutineer
+  I want to scrutineer a final round
+  So that I can tell who won.
+
+  Scenario:  clear cut case
+    Given  couples 101, 102, 103, 104, 105, 106
+    And judges A, B, C, D, E
+    
+    When couple 101 gets 1, 1, 1, 1, 1
+     And couple 102 gets 2, 2, 2, 2, 2
+     And couple 103 gets 3, 3, 3, 3, 3
+     And couple 104 gets 4, 4, 4, 4, 4
+     And couple 105 gets 5, 5, 5, 5, 5
+     And couple 106 gets 6, 6, 6, 6, 6
+     And I compute the results
+     
+    Then couple 101 is in place 1
+     And couple 102 is in place 2
+     And couple 103 is in place 3
+     And couple 104 is in place 4
+     And couple 105 is in place 5
+     And couple 106 is in place 6
+
+  Scenario: Decidable on rule 5
+    Given  couples 101, 102, 103
+    And judges A, B, C
+    
+    When couple 101 gets 1, 1, 1
+     And couple 102 gets 2, 3, 2
+     And couple 103 gets 3, 2, 3
+     And I compute the results
+     
+    Then couple 101 is in place 1
+     And couple 102 is in place 2
+     And couple 103 is in place 3
+
+  Scenario:  requiring rule 6
+    Given  couples 101, 102, 103, 104, 105
+    And judges A, B, C, D, E
+    
+    When couple 101 gets 1, 1, 1, 5, 5
+     And couple 102 gets 4, 2, 4, 1, 2
+     And couple 103 gets 2, 4, 2, 2, 1
+     And couple 104 gets 3, 5, 3, 4, 4
+     And couple 105 gets 5, 3, 5, 3, 3
+     And I compute the results
+    Then couple 101 is in place 1
+     And couple 102 is in place 3
+     And couple 103 is in place 2
+     And couple 104 is in place 5
+     And couple 105 is in place 4
+
+  Scenario:  requiring rule 7
+    Given  couples 101, 102, 103, 104, 105
+    And judges A, B, C, D, E
+                                          
+    When couple 101 gets 1, 1, 1, 5, 5    
+     And couple 102 gets 2, 4, 3, 2, 2    
+     And couple 103 gets 4, 2, 4, 1, 1    
+     And couple 104 gets 3, 5, 2, 4, 4    
+     And couple 105 gets 5, 3, 5, 3, 3    
+     And I compute the results
+    Then couple 101 is in place 1
+     And couple 102 is in place 3
+     And couple 103 is in place 2
+     And couple 104 is in place 5
+     And couple 105 is in place 4

data/stories/final_performance/stories.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), *%w[.. helper])
+
+with_steps_for :scrutineering_a_final_performance do
+  Dir["#{File.dirname(__FILE__)}/*"].each do |file|
+     run file if File.file?(file) && !(file =~ /\.rb$/)
+   end
+end

data/stories/helper.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift File.expand_path("#{File.dirname(__FILE__)}/../lib")
+require 'rubygems'
+require 'skating_system'
+require 'ruby-debug'
+require 'spec'
+require 'spec/story'
+require File.join(File.dirname(__FILE__), *%w[resources steps scrutineering_a_final_performance])

data/stories/resources/steps/scrutineering_a_final_performance.rb

@@ -0,0 +1,43 @@
+steps_for(:scrutineering_a_final_performance) do
+
+  class Judges
+    def initialize(letters)
+      @judge_letters = letters
+    end
+    
+    def hashed_marks(marks)
+      h = {}
+      @judge_letters.each_with_index do |judge, index|
+        h[judge]=marks[index].to_i
+      end
+      h
+    end
+  end
+
+
+  Given /couples ((?:(?:\d+)(?:, )?)+)/ do |numbers|
+    couples = numbers.split(", ")
+    @couples_marks = { }
+    couples.each do |c|
+      @couples_marks[c]={}
+    end
+  end
+
+  Given /judges ((?:(?:\w)(?:, )?)+)/ do |letters|
+    @judges = Judges.new(letters.split(", "))
+  end
+
+  When /couple (\d+) gets ((?:(?:\d+)(?:, )?)+)/ do |number, marks|
+    @couples_marks[number]=@judges.hashed_marks(marks.split(", "))
+  end
+
+  When "I compute the results" do
+    @res=SkatingSystem::PerformanceResults.new
+    @res.score(@couples_marks)
+  end
+  
+  Then "couple $couple is in place $place" do |couple, place|
+    @res[couple][:result].should be(place.to_i)
+  end
+  
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: skating-system
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Wildfalcon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-06 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+description: Convert judges scores from a dance-competition into results
+email: laurie@wildfalcon.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/skating_system.rb
+- lib/skating_system/performance_results.rb
+- lib/skating_system/ranking.rb
+- lib/skating_system/scorer.rb
+- spec/spec.opts
+- spec/spec/performance_results_spec.rb
+- spec/spec/ranking_spec.rb
+- spec/spec/scorer_spec.rb
+- spec/spec_helper.rb
+- stories/all.rb
+- stories/final_performance/final_performance
+- stories/final_performance/stories.rb
+- stories/helper.rb
+- stories/resources/steps/scrutineering_a_final_performance.rb
+has_rdoc: true
+homepage: http://github.com/wildfalcon/skating-system
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Dancesport skating system implementation
+test_files: 
+- spec/spec/performance_results_spec.rb
+- spec/spec/ranking_spec.rb
+- spec/spec/scorer_spec.rb
+- spec/spec_helper.rb