handy_capper 0.1 → 0.1.2

data/.gitignore

@@ -0,0 +1,2 @@
+doc/
+pkg/

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 'ruby-1.9.2-p180@handy_capper'

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+gem 'minitest'
+gem 'ruby-debug19', group: :development

data/Gemfile.lock

@@ -0,0 +1,25 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.5)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    minitest (2.8.1)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest
+  ruby-debug19

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Claude Nix
+
+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.md

@@ -0,0 +1,115 @@
+# HandyCapper
+This is alpha software. It currently only supports PHRF Time on Distance and
+PHRF Time on Time scoring.
+
+## Requirements
+- Ruby 1.9.2 or greater
+- minitest gem (if you want to run the test suite)
+
+## Usage
+
+### Calculating corrected time
+
+```ruby
+class YourApp
+  include HandyCapper
+
+  class Result
+    # installs attr_accessors for required result attributes
+    include HandyCapper::Models::PreliminaryResult
+  end
+end
+
+result = YourApp::Result.new({
+  rating: 222,
+  start_time: '10:00:00',
+  finish_time: '11:30:30',
+  distance: 10.5
+})
+
+# If no options are passed to #phrf, the Time on Distance system will be used
+result.phrf
+# => #<Result ...>
+result.elapsed_time
+# => '01:30:30'
+result.corrected_time
+# => '00:51:39'
+```
+
+#### PHRF Time on Time Scoring
+The PHRF Time on Time scoring method calculates a Time Correction Factor (TCF)
+which is multiplied by the elapsed time to get 'corrected time'. The TCF is
+calculated thusly:
+
+```
+            A
+TCF = -------------
+       B + Rating
+```
+
+Adjusting the _A_ numerator will have no impact on finishing order. It's used
+to generate a pretty coeffecient. It is set to 650 as a default.
+
+Adjusting the _B_ denominator will potentially impact finishing order. It's used
+to represent the conditions for a given race. It is set to 550 as a default, for
+average conditions. Use 480 for heavy air or all off the wind. Use 600 for light
+air or all windward work. 
+
+Corrected time is then calculated as:
+
+```
+corrected = TCF * elapsed time
+```
+
+For more information on PHRF Time on Time scoring, see 
+[http://offshore.ussailing.org/PHRF/Time-On-Time_Scoring.htm][]
+
+```ruby
+result.phrf(formula: :tot, a: 650, b: 550)
+# => #<Result ...>
+result.elapsed_time
+# => '01:30:30'
+result.corrected_time
+# => '01:16:12'
+```
+
+### Scoring a race
+Now that we can correct times, we need to be able to sort a group of corrected
+results and apply points. Currently, HandyCapper only supports scoring a
+single event. Scoring a series, including applying throwouts will be supported
+in a future release.
+
+```ruby
+# get some result objects from a database or something
+results = Result.where('race_id = ?', 1)
+# => [ #<Result ...>, #<Result ...>]
+results.score
+# returns results with position and points set
+# => [ #<Result ...>, #<Result ...>]
+results.first.position
+# => 1
+results.first.points
+# => 1
+```
+
+
+Run the Tests
+-------------
+```bash
+rake test
+```
+
+Utilities
+---------
+Launch an irb session with HandyCapper loaded
+
+```bash
+rake console
+```
+
+Copyright
+---------
+Copyright (c) 2011 Claude Nix. See [LICENSE][] for details.
+
+[license]: https://github.com/cnix/handy_capper/blob/master/LICENSE.md
+[http://offshore.ussailing.org/PHRF/Time-On-Time_Scoring.htm]: http://offshore.ussailing.org/PHRF/Time-On-Time_Scoring.htm

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/handy_capper.rb"
+end

data/handy_capper.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/handy_capper/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.add_development_dependency('ruby-debug19')
+  s.add_development_dependency('minitest')
+  s.authors = ["Claude Nix"]
+  s.description = %q{A Ruby library for calculating corrected scores for common sailboat racing scoring systems}
+  s.email = ['claude@seadated.com']
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files = `git ls-files`.split("\n")
+  s.homepage = 'https://github.com/cnix/handy_capper'
+  s.name = 'handy_capper'
+  s.platform = Gem::Platform::RUBY
+  s.require_paths = ['lib']
+  s.required_rubygems_version = Gem::Requirement.new('>= 1.3.6') if s.respond_to? :required_rubygems_version=
+  s.rubyforge_project = s.name
+  s.summary = %q{A Ruby library for calculating corrected scores for common sailboat racing scoring systems}
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.version = HandyCapper::VERSION.dup
+end

data/lib/handy_capper.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/handy_capper/handy_capper'
+require File.dirname(__FILE__) + '/models/preliminary_result'

data/lib/handy_capper/handy_capper.rb

@@ -0,0 +1,243 @@
+# Public: Various methods for scoring sailing regattas.
+# All methods are instance methods.
+# Currently only PHRF Time on Time and PHRF Time on Distance are supported.
+module HandyCapper
+
+  # Public: Applies position and points to a group of results
+  #
+  # sort -  Result attribute to sort by. (default: :corrected_time)
+  #         :one_design     - sort by elapsed_time
+  #         :corrected_time - sort by corrected_time
+  #
+  # Examples
+  #
+  #   # get some result objects from a database or something
+  #   results = Result.where('race_id = ?', 1)
+  #   # => [ #<Result ...>, #<Result ...>]
+  #   results.score(:corrected_time)
+  #   # returns results with position and points set
+  #   # => [ #<Result ...>, #<Result ...>]
+  #   results.first.position
+  #   # => 1
+  #   results.first.points
+  #   # => 1
+  #
+  # Returns receiver(Array) with position and points set for each item in the array
+  def score(sort = :corrected_time)
+    sort = (sort == :one_design) ? :elapsed_time : :corrected_time
+    sorted_results = self.sort_by { |h| h[sort] }
+
+    sorted_results.each_with_index do |result, index|
+      result.position = index + 1
+      calculate_points(result, sorted_results.length)
+    end
+
+    sorted_results
+  end
+
+  # Public: Corects a result with the PHRF scoring system.
+  # See http://http://offshore.ussailing.org/PHRF.htm
+  #
+  # options - Hash for setting a different PHRF scoring method (default: {})
+  #           :formula -  If you wish to use Time on Time, pass the Symbol :tot
+  #                       Additionally, you can set the numerator and 
+  #                       denominator for the Time on Time formula by setting
+  #                       values for :a & :b
+  #           :a       -  Set :a to a Fixnum to set the numerator of the formula
+  #           :b       -  Set :b to a Fixnum to set the denominator of the formula
+  #
+  # Examples
+  #
+  #   # Assuming a class named Result in your application
+  #   result = Result.new({
+  #     rating: 222,
+  #     start_time: '10:00:00',
+  #     finish_time: '11:30:30',
+  #     distance: 10.5
+  #   })
+  #
+  #   result.phrf
+  #   # => #<Result ...>
+  #   result.elapsed_time
+  #   # => '01:30:30'
+  #   result.corrected_time
+  #   # => '00:59:50'
+  #
+  #   # Using default settings for Time on Time formula
+  #   result.phrf(formula: :tot)
+  #   # => #<Result ...>
+  #   result.corrected_time
+  #   # => '01:16:12'
+  #
+  #   # Change the denominator to accommodate conditions
+  #   result.phrf(formula: :tot, b: 480) # heavy air
+  #   # => #<Result ...>
+  #   result.corrected_time
+  #   # => '01:23:48'
+  #
+  # Returns receiver with elapsed_time and corrected_time set
+  # Raises AttributeError if a required attribute is missing from the receiver
+  def phrf(options={})
+
+    unless rating && start_time && finish_time
+      raise AttributeError, "You're missing a required attribute to process this result"
+    end
+
+    self.elapsed_time = calculate_elapsed_time(self)
+
+    if options[:formula] == :tot
+      a = options[:a] || 650 # generic numerator
+      b = options[:b] || 550 # average conditions
+      ct_in_seconds = score_with_phrf_time_on_time(a,b)
+    else
+      ct_in_seconds = score_with_phrf_time_on_distance
+    end
+
+    self.corrected_time = convert_seconds_to_time(ct_in_seconds)
+    self.elapsed_time = convert_seconds_to_time(self.elapsed_time)
+
+    self
+  end
+
+  private
+
+  # Internal: Calculate corrected time with PHRF Time on Distance
+  #
+  # result - corrected time in seconds
+  #
+  # Examples
+  #
+  #   Result = Struct.new(:elapsed_time, :rating, :distance)
+  #   result = Result.new(5400, 222, 10.5)
+  #   result.score_with_phrf_time_on_distance
+  #   # => 3069
+  #
+  # Returns a Fixnum
+  def score_with_phrf_time_on_distance
+    cf  = self.rating
+    et  = self.elapsed_time
+    d   = self.distance
+
+    (et - (d * cf)).round
+  end
+
+  # Internal: Calculate corrected time in seconds with PHRF Time on Time
+  #
+  # a - Numerator for TOT formula. Does not affect position.
+  # b - Denominator for TOT formula. This one affects position.
+  #
+  # Examples
+  #
+  #   Result = Struct.new(:elapsed_time, :rating)
+  #   result = Result.new(5400, 222)
+  #   result.score_with_phrf_time_on_time(b: 480)
+  #   # => 5000
+  #   result.score_with_phrf_time_on_time(b: 600)
+  #   # => 4270
+  #
+  # Returns a Fixnum representing corrected time in seconds
+  def score_with_phrf_time_on_time(a, b)
+    tcf = a.to_f / ( b.to_f + self.rating.to_f )
+    (self.elapsed_time * tcf).round
+  end
+
+  # Internal: Calculate delta in seconds between two time objects
+  #
+  # result - an object with a start_time and a finish_time attribute
+  #
+  # Examples
+  #
+  #   Result = Struct.new(:start_time, :finish_time)
+  #   result = Result.new("10:00:00", "11:30:00")
+  #   calculate_elapsed_time(result)
+  #   # => 5400
+  #
+  # Returns a Fixnum 
+  def calculate_elapsed_time(result)
+    Time.parse(result.finish_time).to_i - Time.parse(result.start_time).to_i
+  end
+
+  # Internal: Covert seconds to a string of seconds
+  #
+  # seconds - a Fixnum representing time in seconds
+  #
+  # Examples
+  #
+  #   convert_seconds_to_time(5400)
+  #   # => '01:30:00'
+  #
+  # Returns a string
+  def convert_seconds_to_time(seconds)
+    Time.at(seconds).gmtime.strftime('%R:%S')
+  end
+
+  # Internal: Calculate the points for a scored result
+  #
+  # result        - A Result object
+  # total_results - A Fixnum representing the number of results in the set
+  #
+  # Examples
+  #
+  #   first_place_boat = Result.new({
+  #     corrected_time: '01:30:41',
+  #     position:       1,
+  #     code:           nil
+  #   })
+  #   calculate_points(first_place_boat, 10)
+  #   # => #<Result ...>
+  #   first_place_boat.points
+  #   # => 1
+  #   
+  #   dnf_boat = Result.new({
+  #     corrected_time: nil,
+  #     position:       10,
+  #     code:           'DNF'
+  #   })
+  #   calculate_points(dnf_boat, 10)
+  #   # => #<Result ...>
+  #   dnf_boat.points
+  #   # => 11
+  #
+  # Returns the receiver with the points attribute set to a Fixnum
+  def calculate_points(result, total_results)
+    if result.code
+      calculate_points_with_penalty(result, total_results)
+    else
+      result.points = result.position
+    end
+    result
+  end
+
+  # Internal: Calculate points based on a penalty code
+  def calculate_points_with_penalty(result, total_results)
+    if ONE_POINT_PENALTY_CODES.include?(result.code)
+      result.points = total_results + 1
+    elsif TWENTY_PERCENT_PENALTY_CODES.include?(result.code)
+      penalty_points = (total_results * 0.20).round
+      if (penalty_points + result.position) > (total_results + 1)
+        result.points = total_results + 1
+      else
+        result.points = result.position + penalty_points
+      end
+    else
+      result.points = result.position
+    end
+    result
+  end
+
+  # Internal: Array of String penalty codes that apply the n + 1 penalty where
+  # n = the total number of entries for a fleet
+  ONE_POINT_PENALTY_CODES = [
+    'DSQ', 'DNS', 'DNC', 'DNF',
+    'OCS', 'BFD', 'DGM', 'DNE',
+    'RAF'
+  ]
+
+  # Internal: Array of String penalty codes that apply the 20% penalty
+  TWENTY_PERCENT_PENALTY_CODES = [ 'ZFP', 'SCP' ]
+
+  # Internal: Error that is raised when required attributes are missing from a
+  # receiver for PHRF scoring
+  class AttributeError < StandardError; end
+
+end

data/lib/handy_capper/version.rb

@@ -0,0 +1,4 @@
+module HandyCapper
+  # Public: Version number for this release
+  VERSION = '0.1.2'.freeze unless defined?(::HandyCapper::VERSION)
+end

data/lib/models/preliminary_result.rb

@@ -0,0 +1,31 @@
+module HandyCapper
+  # Public: Namespace for model-like modules
+  module Models
+    # Public: Include this module in your result class to get required attributes
+    # for scoring the results. Alternatively, you can alias these to whatever
+    # you have called them in your application
+    module PreliminaryResult
+
+      # Public: Array of Symbols passed attr_accessor on base class
+      DEFAULT_PROPERTIES = [
+        :rating,
+        :start_time,
+        :finish_time,
+        :elapsed_time,
+        :corrected_time,
+        :distance,
+        :penalty,
+        :code,
+        :avg_speed
+      ]
+
+      # Public: Installs attributes on a class where this module is included
+      def self.included(base)
+        DEFAULT_PROPERTIES.each do |p|
+          base.send(:attr_accessor, p)
+        end
+      end
+
+    end
+  end
+end

data/test/handy_capper/handy_capper_test.rb

@@ -0,0 +1,225 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'ruby-debug'
+
+describe HandyCapper do
+  before do
+    Result = Struct.new(
+      :rating,
+      :start_time,
+      :finish_time,
+      :distance,
+      :elapsed_time,
+      :corrected_time,
+      :position,
+      :points,
+      :code
+    )
+  end
+
+  after do
+    # silence warnings for already initialized constant
+    # this could probably be done better if it wasn't a Struct. =\
+    Object.send(:remove_const, :Result)
+  end
+
+  describe "#score" do
+    before do
+      @corrected_results = []
+      10.times do
+        result = Result.new
+        # TODO: Address potential race condition
+        time = Time.parse("#{[*0..3].sample}:#{[*0..59].sample}:#{[*0..59].sample}").strftime('%R:%S')
+        result.corrected_time = time
+        @corrected_results << result
+      end
+
+      @one_design_results = []
+      10.times do
+        result = Result.new
+        # TODO: Address potential race condition
+        time = Time.parse("#{[*0..3].sample}:#{[*0..59].sample}:#{[*0..59].sample}").strftime('%R:%S')
+        result.elapsed_time = time
+        @one_design_results << result
+      end
+    end
+
+    describe "one design" do
+      it "should sort results by elapsed_time" do
+        scored_results = @one_design_results.score(:one_design)
+
+        previous = '0'
+        scored_results.each do |r|
+          this = r.elapsed_time
+          (this > previous).must_equal true
+          previous = this
+        end
+      end
+    end
+
+    describe "corrected time" do
+      it "should sort the results by corrected_time" do
+        scored_results = @corrected_results.score
+
+        previous = '0'
+        scored_results.each do |r|
+          this = r.corrected_time
+          (this > previous).must_equal true
+          previous = this
+        end
+      end
+    end
+
+    it "should add position to the result" do
+      scored_results = @corrected_results.score
+
+      scored_results.each do |r|
+        r.position.wont_be_nil
+      end
+    end
+  end
+
+  describe "#phrf" do
+    before do
+      @result = Result.new( 222, '10:00:00', '11:30:30', 10.6)
+    end
+
+    it "should set the elapsed time" do
+      @result.phrf.elapsed_time.wont_be_nil
+    end
+
+    it "should set the corrected time" do
+      @result.phrf.corrected_time.wont_be_nil
+    end
+
+    it "should require a rating" do
+      @result.rating = nil
+      -> { @result.phrf }.must_raise AttributeError
+    end
+
+    it "should require a start time" do
+      @result.start_time = nil
+      -> { @result.phrf }.must_raise AttributeError
+    end
+
+    it "should require a finish time" do
+      @result.finish_time = nil
+      -> { @result.phrf }.must_raise AttributeError
+    end
+
+    it "should default to PHRF Time On Distance" do
+      @result.phrf.corrected_time.must_equal '00:51:17'
+    end
+  end
+
+  describe "#score_with_phrf_time_on_distance" do
+    before do
+      # set elapsed time to seconds so we don't need to convert to test this
+      @result = Result.new(222, '10:00:00', '11:30:30', 10.6, 5430)
+    end
+
+    it "should calculate corrected time with Time on Distance formula" do
+      corrected_time_in_seconds = @result.send(:score_with_phrf_time_on_distance)
+      corrected_time_in_seconds.must_be_instance_of Fixnum
+      corrected_time_in_seconds.must_equal 3077
+    end
+  end
+
+  describe "#score_with_phrf_time_on_time" do
+    before do
+      @result = Result.new(222, '10:00:00', '11:30:30', nil, 5430)
+    end
+
+    it "should calculate corrected time with Time on Time formula" do
+      corrected_time_in_seconds = @result.send(:score_with_phrf_time_on_time, 650,550)
+      corrected_time_in_seconds.must_be_instance_of Fixnum
+      corrected_time_in_seconds.must_equal 4572
+    end
+
+    it "should allow configuration of time on time numerator" do
+      corrected_time_in_seconds = @result.send(:score_with_phrf_time_on_time, 550,550)
+      corrected_time_in_seconds.must_equal 3869
+    end
+
+    it "should allow configuration of time on time denominator" do
+      corrected_time_in_seconds = @result.send(:score_with_phrf_time_on_time, 650,480)
+      corrected_time_in_seconds.must_equal 5028
+    end
+  end
+
+  describe "#calculate_elapsed_time" do
+    before do
+      @result = Result.new( 222, '10:00:00', '11:30:30', 10.6)
+    end
+
+    it "should return a Fixnum representing time in seconds" do
+      seconds = calculate_elapsed_time(@result)
+      seconds.must_be_instance_of Fixnum
+      seconds.must_equal 5430
+    end
+  end
+
+  describe "#convert_seconds_to_time" do
+    before do
+      @result = Result.new( 222, '10:00:00', '11:30:30', 10.6)
+    end
+
+    it "should accept a Fixnum" do
+      -> { convert_seconds_to_time("90") }.
+        must_raise TypeError
+    end
+
+    it "should return a Time" do
+      time = convert_seconds_to_time(90)
+      time.must_be_instance_of String
+      time.must_equal "00:01:30"
+    end
+  end
+
+  describe "#calculate_points" do
+    before do
+      @result = Result.new
+      @result.position = 2
+    end
+
+    it "should set the points for a result" do
+      calculate_points(@result, 10)
+      @result.points.must_equal 2
+    end
+
+    describe "penalty scoring" do
+
+      describe "when the penalty code is a n + 1 code" do
+
+        it "should set points based on ISAF penalty code" do
+          ['DSQ', 'DNS', 'DNF', 'DNC', 'OCS', 'BFD', 'DGM', 'DNE', 'RAF'].each do |c|
+            @result.code = c
+            calculate_points(@result, 10)
+            @result.points.must_equal 11
+          end
+
+        end
+      end
+
+      describe "when the penalty code is a 20% penalty" do
+
+        it "should apply the 20% penalty" do
+          [ 'ZFP', 'SCP' ].each do |c|
+            @result.code = c
+            calculate_points(@result, 10)
+            @result.points.must_equal 4
+          end
+        end
+
+        it "should not apply a penalty greater than n + 1" do
+          [ 'ZFP', 'SCP' ].each do |c|
+            @result.code = c
+            @result.position = 10
+            calculate_points(@result, 10)
+            @result.points.must_equal 11
+          end
+        end
+
+      end
+    end
+  end
+end

data/test/models/preliminary_result_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+describe HandyCapper::Models::PreliminaryResult do
+  describe ".included" do
+    before :each do
+      class Result; include HandyCapper::Models::PreliminaryResult; end
+
+      DEFAULT_PROPERTIES = [
+        :rating,
+        :start_time,
+        :finish_time,
+        :elapsed_time,
+        :corrected_time,
+        :distance,
+        :penalty,
+        :code,
+        :avg_speed
+      ]
+    end
+
+    it "should install the default attributes when included in a class" do
+      result = Result.new
+
+      DEFAULT_PROPERTIES.each do |p|
+        result.must_respond_to p
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/pride'
+require File.dirname(__FILE__) + '/../lib/handy_capper'
+
+include HandyCapper
+

metadata

@@ -2,7 +2,7 @@
 name: handy_capper
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: "0.1"
+  version: 0.1.2
 platform: ruby
 authors: 
 - Claude Nix
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-05 00:00:00 -05:00
+date: 2011-12-08 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -44,8 +44,22 @@ extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- handy_capper.gemspec
+- lib/handy_capper.rb
+- lib/handy_capper/handy_capper.rb
+- lib/handy_capper/version.rb
+- lib/models/preliminary_result.rb
+- test/handy_capper/handy_capper_test.rb
+- test/models/preliminary_result_test.rb
+- test/test_helper.rb
 has_rdoc: true
 homepage: https://github.com/cnix/handy_capper
 licenses: []
@@ -74,5 +88,7 @@ rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: A Ruby library for calculating corrected scores for common sailboat racing scoring systems
-test_files: []
-
+test_files: 
+- test/handy_capper/handy_capper_test.rb
+- test/models/preliminary_result_test.rb
+- test/test_helper.rb