opensprints-core 0.5.1

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "opensprints-core"
+    gem.summary = %Q{A lib for interacting with opensprints race records data}
+    gem.description = %Q{This contains everything common between the stats app and the opensprints shoes app. If you want to write a new application to display opensprints stats or run races, this is your gem. }
+    gem.email = "evanfarrar@gmail.com"
+    gem.homepage = "http://github.com/evanfarrar/opensprints-core"
+    gem.authors = ["Evan Farrar"]
+    gem.add_development_dependency "bacon"
+    gem.add_dependency "sequel"
+    # 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: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'test/test_*.rb'
+  spec.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |spec|
+    spec.libs << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "opensprints-core #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.1

data/lib/categorization.rb

@@ -0,0 +1,5 @@
+# TODO: when the sequel move is complete, this join model is probably useless.
+class Categorization < Sequel::Model
+  many_to_one :category
+  many_to_one :racer
+end

data/lib/category.rb

@@ -0,0 +1,15 @@
+class Category < Sequel::Model
+  def to_s
+    self.name
+  end
+
+  def Category.next_after(other)
+    if(other)
+      category = Category.filter(:id > other.pk).order(:id).first
+    else
+      category = Category.order(:id).first
+    end
+    category ? category.pk : nil
+  end
+
+end

data/lib/migrations/001_create_categories.rb

@@ -0,0 +1,14 @@
+class CreateCategories < Sequel::Migration
+  def up
+    create_table :categories do
+      primary_key :id
+      String :name
+      DateTime :created_at
+    end
+  end
+
+  def down
+    drop_table(:categories)
+  end
+end
+

data/lib/migrations/002_create_racers.rb

@@ -0,0 +1,14 @@
+class CreateRacers < Sequel::Migration
+  def up
+    create_table :racers do
+      primary_key :id
+      String :name
+      DateTime :created_at
+    end
+  end
+
+  def down
+    drop_table(:racers)
+  end
+end
+

data/lib/migrations/003_create_categorizations.rb

@@ -0,0 +1,17 @@
+class CreateCategorizations < Sequel::Migration
+  def up
+    create_table(:categorizations, :ignore_index_errors=>true) do
+      primary_key :id
+      Integer :racer_id, :null=>false
+      Integer :category_id, :null=>false
+      
+      index [:category_id], :name=>:index_categorizations_category
+      index [:racer_id], :name=>:index_categorizations_racer
+    end
+  end
+
+  def down
+    drop_table(:categorizations)
+  end
+end
+

data/lib/migrations/004_create_races.rb

@@ -0,0 +1,24 @@
+class CreateRaces < Sequel::Migration
+  def up
+    create_table :races do
+      primary_key :id
+      TrueClass :raced, :default => false
+      Integer :tournament_id
+    end
+    create_table(:race_participations, :ignore_index_errors=>true) do
+      primary_key :id
+      BigDecimal :finish_time, :size=>[10, 0]
+      Integer :racer_id, :null=>false
+      Integer :race_id, :null=>false
+
+      index [:race_id], :name=>:index_race_participations_race
+      index [:racer_id], :name=>:index_race_participations_racer
+    end
+  end
+
+  def down
+    drop_table(:races)
+    drop_table(:race_participations)
+  end
+end
+

data/lib/migrations/005_create_tournaments.rb

@@ -0,0 +1,24 @@
+class CreateTournaments < Sequel::Migration
+  def up
+    create_table(:tournament_participations, :ignore_index_errors=>true) do
+      primary_key :id
+      TrueClass :eliminated
+      Integer :racer_id, :null=>false
+      Integer :tournament_id, :null=>false
+      
+      index [:racer_id], :name=>:index_tournament_participations_racer
+      index [:tournament_id], :name=>:index_tournament_participations_tournament
+    end
+    
+    create_table(:tournaments) do
+      primary_key :id
+      String :name, :size=> 140
+    end
+  end
+
+  def down
+    drop_table(:tournaments)
+    drop_table(:tournament_participations)
+  end
+end
+

data/lib/opensprints-core.rb

@@ -0,0 +1,21 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'sequel'
+require 'sequel/extensions/migration'
+require 'sequel/extensions/schema_dumper'
+require 'sqlite3'
+if(defined? Shoes) #Real environment
+  DB = Sequel.connect("sqlite://#{DATABASE_PATH}")
+else               #Test environment
+  DB = Sequel.connect("sqlite::memory:")
+end
+Sequel::Migrator.apply(DB, 'lib/migrations/')
+Infinity = 1/0.0
+require 'lib/tournament'
+require 'lib/tournament_participation'
+require 'lib/category'
+require 'lib/racer'
+require 'lib/race'
+require 'lib/race_participation'
+require 'lib/categorization'

data/lib/race.rb

@@ -0,0 +1,27 @@
+class Race < Sequel::Model
+  one_to_many :race_participations
+  many_to_many :racers, :join_table => :race_participations
+  many_to_one :tournament
+
+  def finished?
+    race_participations.all?(&:finish_time)
+  end
+
+  def winner
+    if unraced?
+      return nil
+    else
+      standings = self.race_participations.sort_by { |racer| racer.finish_time||Infinity }
+      standings.first
+    end
+  end
+ 
+  def unraced?
+    !raced
+  end
+
+  def next_race
+    (Race.filter(:raced => false, :tournament_id => tournament.pk).all - [self]).first
+  end
+
+end

data/lib/race_participation.rb

@@ -0,0 +1,60 @@
+class RaceParticipation < Sequel::Model
+  many_to_one :race
+  many_to_one :racer
+
+  def color
+    @color ||= $BIKES[self.race.race_participations.index(self)]
+  end
+
+  attr_accessor :ticks
+
+  def percent_complete
+    [1.0, self.distance / $RACE_DISTANCE].min
+  end
+
+  def distance
+    if self.ticks
+      self.ticks * $ROLLER_CIRCUMFERENCE
+    else
+      0.0
+    end
+  end
+
+  METERS_PER_MILLISECOND_TO_MILES_PER_HOUR = 2236.93629
+  METERS_PER_MILLISECOND_TO_KILOMETERS_PER_HOUR = 3600.0
+  def unit_conversion
+    case UNIT_SYSTEM
+      when :mph
+        @unit_conversion = METERS_PER_MILLISECOND_TO_MILES_PER_HOUR
+      when :kph
+        @unit_conversion = METERS_PER_MILLISECOND_TO_KILOMETERS_PER_HOUR
+    end
+  end
+
+  # yikes.
+  def speed(time)
+    @unit_conversion ||= unit_conversion
+    @distance = self.distance
+    @time = time
+    @distance_old ||= 0
+    @time_old ||= 0
+    @speed ||= 0
+    if(@time_old > @time)
+      @time_old = time
+    end
+    if time == 0
+      0
+    else
+      if(@time-@time_old > 999)
+        if(@distance_old > 0)
+          @speed = "%.2f" % (((@distance - @distance_old) / (@time - @time_old)) * @unit_conversion).to_f
+        else
+          @speed = 0
+        end
+        @distance_old = @distance
+        @time_old = @time
+      end
+      @speed
+    end
+  end
+end

data/lib/racer.rb

@@ -0,0 +1,12 @@
+class Racer < Sequel::Model
+  one_to_many :categorizations
+  many_to_many :categories, :join_table => :categorizations
+  def to_s
+    name
+  end
+
+  def best_time
+    best = DB[:race_participations].filter(:racer_id => self.pk).order(:finish_time).select(:finish_time).first
+    best[:finish_time] if best
+  end
+end

data/lib/tournament.rb

@@ -0,0 +1,46 @@
+class Tournament < Sequel::Model
+  one_to_many :tournament_participations
+  many_to_many :racers, :join_table => :tournament_participations
+  one_to_many :races
+
+  def unregistered_racers
+    Racer.exclude(:id => Racer.join(:tournament_participations, :racer_id => :id).select(:racers__id)).all
+  end
+
+  def autofill(racer_list=nil)
+    racer_list ||= reload.unmatched_racers.to_a
+    racer_list.each_slice($BIKES.length) { |a|
+      race = Race.create(:tournament => self)
+      a.map{|r| RaceParticipation.create(:racer => r, :race => race)}
+    }
+  end
+
+  def unmatched_racers
+    racers - matched_racers - tournament_participations.select{|tp|tp.eliminated}.map{|tp|tp.racer}
+  end
+
+  def matched_racers
+    matched = []
+    matches = self.races.select{|race| race.unraced? }
+    matches.each { |race|
+      race.race_participations.each {|rp|
+        matched << rp.racer
+      }
+    }
+    matched
+  end
+
+  #TODO: test
+  def never_raced_and_not_eliminated
+    matched = []
+    races.each { |race|
+      race.race_participations.each {|rp|
+        matched << rp.racer
+      }
+    }
+    racers - matched - tournament_participations.select{|tp|tp.eliminated}.map{|tp|tp.racer}
+  end
+
+
+
+end

data/lib/tournament_participation.rb

@@ -0,0 +1,31 @@
+class TournamentParticipation < Sequel::Model
+  many_to_one :racer
+  many_to_one :tournament
+
+  def best_time
+    best = DB[:race_participations].filter(:racer_id => racer.id).exclude(:finish_time => nil).join(:races, :tournament_id => tournament.id).filter(:raced => true).order(:finish_time).select(:finish_time).first
+
+    best[:finish_time] if best
+  end
+
+  def rank
+    standings = self.tournament.tournament_participations.sort_by{|tp|tp.best_time||Infinity}
+    standings.index(self)+1
+  end
+
+  def losses
+    RaceParticipation.filter(:racer_id => racer.id).join(:races, :tournament_id => tournament.id).group(:id).all.select do |rp|
+      winner = rp.race ? rp.race.winner : nil
+      winner && (winner.racer.pk != self.racer.pk)
+    end.length
+  end
+
+  def eliminate
+    self.update(:eliminated => true)
+  end
+
+  def race_participations
+    RaceParticipation.filter(:racer_id => racer.id).join(:races, :tournament_id => tournament.id).group(:id).all
+  end
+
+end

data/test/opensprints-core_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "OpensprintsCore" do
+  it "fails" do
+    should.flunk "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/test/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bacon'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'opensprints-core'
+
+Bacon.summary_on_exit

data/test/test_category.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'bacon'
+require 'lib/opensprints-core.rb'
+
+describe 'A category' do
+  before do
+    @category = Category.new
+  end
+
+  it 'should have a name' do
+    @category.name = "Women"
+    @category.name.should=="Women"
+  end
+  it 'should save' do
+    c = Category.new(:name => "Test")
+    (!!c.save).should==(true)
+  end
+
+  it 'should load from the database' do
+    c = Category.new(:name => "Test")
+    (!!c.save).should==(true)
+    Category[c.id].should.not.be.nil?
+  end
+
+  it 'should be convertible to string' do
+    Category.new(:name => "Men").to_s.should=="Men"
+  end
+
+  describe "next after" do
+    before do 
+      Category.all.each{|c|c.destroy}
+      @c1 = Category.create(:name => "one")
+      @c2 = Category.create(:name => "two")
+    end
+    it "should know what category comes after no category" do
+      Category.next_after(nil).should==(@c1.pk)
+    end
+    it "should know what category comes after a given category" do
+      Category.next_after(@c1).should==(@c2.pk)
+    end
+    it "should know no category comes after a the last category" do
+      Category.next_after(@c2).should==(nil)
+    end
+    it 'should work with no categories' do
+      Category.all.each{|c|c.destroy}
+      Category.next_after(nil).should==(nil)
+    end
+    after do
+      Category.all.each{|c|c.destroy}
+      Category.create(:name => "Men")
+      Category.create(:name => "Women")
+    end
+  end
+
+end

data/test/test_race.rb

@@ -0,0 +1,112 @@
+require 'rubygems'
+require 'bacon'
+require 'lib/opensprints-core.rb'
+$BIKES = ["red","blue"]
+
+describe 'A race' do
+  before do
+    @race = Race.new
+  end
+
+  it 'should be able to create race with racers' do
+    racers = [Racer.create, Racer.create, Racer.create, Racer.create]
+    r = Race.create
+    racers.map{|e| RaceParticipation.create(:racer => e, :race => r)}
+    r.save
+    Race[r.pk].racers.length.should==4
+  end
+
+  describe "racers" do
+    it "should have a color" do
+      racers = [Racer.create, Racer.create, Racer.create, Racer.create]
+      r = Race.create
+      racers.map{|e| RaceParticipation.create(:racer => e, :race => r)}
+      r.save
+      r.race_participations.first.color.should== $BIKES.first
+    end
+  end
+
+  it 'should have times' do
+    racers = [Racer.create, Racer.create, Racer.create, Racer.create]
+    r = Race.create
+    racers.map{|e| RaceParticipation.create(:racer => e, :race => r)}
+    r.save
+    r.race_participations.first.finish_time = 10.116
+    r.race_participations.first.save
+    r.reload
+    r.race_participations.first.finish_time.should==(10.116)
+  end
+
+  it 'should be finished if everyone has times.' do
+    racers = [Racer.create, Racer.create, Racer.create, Racer.create]
+    r = Race.create
+    racers.map{|e| RaceParticipation.create(:racer => e, :race => r)}
+    r.save
+    r.race_participations.first.finish_time = 10.116
+    r.race_participations.first.save
+    r.reload
+    r.finished?.should==(false)
+    r.race_participations.each{|rp|rp.finish_time = 10.116; rp.save}
+    r.reload
+    r.finished?.should==(true)
+  end
+
+  describe 'winner' do
+    it 'should be the lowest (fastest) time' do
+      racers = [Racer.create(:name => "Steve"),
+                Racer.create(:name => "Joe")]
+      r = Race.create(:raced => true)
+      racers.each{|racer| RaceParticipation.create(:racer => racer,:race => r)} 
+      r.save
+      r.race_participations.first.finish_time = 10.116
+      r.save
+      r.reload
+      r.winner.racer.name.should==("Steve")
+    end
+
+    it 'should be nil if the race has not been run' do
+      racers = [Racer.create(:name => "Steve"),
+                Racer.create(:name => "Joe")]
+      r = Race.create
+      racers.each{|racer| RaceParticipation.create(:racer => racer,:race => r)} 
+      r.save
+      r.race_participations.first.finish_time = 10.116
+      r.save
+      r.reload
+      r.winner.should==(nil)
+    end
+  end
+  describe 'raced' do
+    it 'should track whether or not the race has been run' do
+      r = Race.create
+      r.raced.should==(false) 
+      r.raced = true
+      r.raced.should==(true) 
+    end
+
+    it 'should have a converse: unraced?' do
+      r = Race.create
+      r.unraced?.should==(true) 
+      r.raced = true
+      r.unraced?.should==(false) 
+    end
+  end
+
+  describe 'next race' do
+    it 'should be the next one after this one' do
+      t = Tournament.create
+      r1 = Race.create(:tournament => t)
+      r2 = Race.create(:tournament => t)
+      r1.next_race.should==(r2)
+    end
+
+    it 'should only show the next unraced race' do
+      t = Tournament.create
+      r1 = Race.create(:tournament => t)
+      r2 = Race.create(:tournament => t, :raced => true)
+      r3 = Race.create(:tournament => t)
+      r1.next_race.should==(r3)
+    end
+  end
+
+end

data/test/test_race_paricipation.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'bacon'
+require 'lib/opensprints-core.rb'
+
+describe 'A race participation' do
+  before do
+    @r = RaceParticipation.new
+  end
+
+  it 'should have a temporary place for keeping track of ticks' do
+    @r.ticks = 12
+    @r.ticks.should==(12)
+  end
+
+  it 'should have a distance' do
+    $ROLLER_CIRCUMFERENCE = 0.5
+    @r.ticks = 42
+    @r.distance.should==(21.0)
+  end
+
+  describe 'percent complete' do
+    it 'should be the ratio of race distance to distance' do
+      $RACE_DISTANCE = 84.0
+      $ROLLER_CIRCUMFERENCE = 0.5
+      @r.ticks = 42
+      @r.percent_complete.should==(0.25)
+      @r.ticks = 0
+      @r.percent_complete.should==(0.0)
+      @r.ticks = 1200.0
+      @r.percent_complete.should==(1.0)
+    end
+  end
+
+  describe 'speed' do
+#    it 'should give a speed based on a certain time'
+  end
+end

data/test/test_racer.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'bacon'
+require 'lib/opensprints-core.rb'
+
+describe 'A racer' do
+  before do
+      @racer = Racer.new
+  end
+
+  it 'should have a name' do
+    @racer.name = "Evan F"
+    @racer.name.should=="Evan F"
+    @racer.to_s.should=="Evan F"
+  end
+
+  it 'should save' do
+    r = Racer.new(:name => "Test")
+    (!!r.save).should==(true)
+  end
+
+  it 'should load from the database' do
+    r = Racer.new(:name => "Test")
+    (!!r.save).should==(true)
+    Racer[r.pk].should.not.be.nil?
+  end
+
+  it "should have categories" do
+    c = Category.create(:name => "Men")
+#    @racer.categories << c
+
+    @racer.save
+    Categorization.create(:category => c, :racer => @racer)
+    @racer.reload.categorizations.map(&:category).should.include? c
+    @racer.categories.should.include? c
+  end
+
+  it "should know the best time ever" do
+    racer = Racer.create
+    [7.0, 12.0, 2.7, 10.0].each do |time|
+      race = Race.create
+      RaceParticipation.create(:finish_time => time, :race => race, :racer => racer)
+    end
+    racer.best_time.should==(2.7)
+  end
+end