rrschedule 0.1.3 → 0.1.4

data/README.rdoc

@@ -1,6 +1,6 @@
 = rrschedule
 
-rrschedule makes it easier to generate Round-Robin schedules for sport leagues. To generate a schedule, it needs a team list, a season 
+rrschedule makes it easier to generate round-robin schedules for sport leagues. To generate a schedule, it needs a team list, a season 
 start date, the day(s) of the week where the games are played and some other options.
 
 It takes into consideration physical constraints such as the number of playing surfaces availables and game times.
@@ -8,13 +8,13 @@ Each round of the round-robin is splitted into multiple gamedays that respect th
 
 Say for example that you want to generate a round-robin schedule for your 15-teams volleyball league. 
 If there are only 3 volleyball fields available and that games are played each monday at 6PM and 8PM, this is technically 
-impossible to complete one round in a single day. rrschedule will put the remaining games of this round on the next gameday 
+impossible to complete one round in a single day. So rrschedule will put the remaining games of this round on the next gameday 
 and will start a new round right after.
 
 
 == Installation
   gem install rrschedule
-  require 'rrschedule.rb'
+  require 'rrschedule'
 
 == Prepare the schedule
   Time.zone = "America/New_York"
@@ -42,10 +42,10 @@ and will start a new round right after.
                                                       Time.zone.parse("2010/12/29")
                                                     ],
                                                     
-                                  #1 for Round Robin, 2 for Double Round Robin and so on
+                                  #1 for Round Robin, 2 for Double Round Robin and so on. Default is 1
                                   :cycles => 1,
                                   
-                                  #Shuffle team order before each cycle
+                                  #Shuffle team order before each cycle. Default is true
                                   :shuffle_initial_order => true,
                                   
                                   #Times of the day where the games are played
@@ -95,9 +95,13 @@ and will start a new round right after.
     puts "\n"
   end
   
-== Other
+== Issues / Other
+
+Playing surfaces and game times need to be distributed evenly among all competitors. At the moment
+the same teams will play on the same surfaces and at the same game times most of the time.
+Note that it only happens when a full round can be completed on a single gameday. Otherwise there will
+be a natural rotation and teams will play on different surfaces and at different times between gamedays.
 
 Hope this gem will be useful to some people!
-As you can see, there are no tests yet but they should come quite soon.
 
 You can read my blog here: www.rubyfleebie.com

data/Rakefile

@@ -11,6 +11,7 @@ begin
     gem.homepage = "http://github.com/flamontagne/rrschedule"
     gem.authors = ["flamontagne"]
     gem.add_dependency 'activesupport'
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/lib/rrschedule.rb

@@ -8,14 +8,26 @@ module RRSchedule
     attr_reader :teams, :rounds
 
     def initialize(params={})
-      self.teams = params[:teams] || [1,2,3,4,5]
-      self.playing_surfaces = params[:playing_surfaces] || ["--"]
+      self.teams = params[:teams] || [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
+      self.playing_surfaces = Array(params[:playing_surfaces]).empty? ? ["Surface A", "Surface B"] : Array(params[:playing_surfaces])
       self.cycles = params[:cycles] || 1
-      self.game_times = params[:game_times] || ["Game time not specified"]
+      
+      self.game_times = Array(params[:game_times]).empty? ? ["7:00 PM", "9:00 PM"] : Array(params[:game_times])
+      self.game_times.collect! do |gt| 
+        begin
+          DateTime.parse(gt) 
+        rescue
+          raise "game times must be valid time representations in the string form (e.g. 3:00 PM, 11:00 AM, 18:20, etc)"
+        end
+      end
+      
       self.shuffle_initial_order = params[:shuffle_initial_order] || true
       self.exclude_dates = params[:exclude_dates] || []
       self.start_date = params[:start_date] || Time.now.beginning_of_day
       self.wdays = Array(params[:wdays]).empty? ? [1] : Array(params[:wdays])
+      
+      raise "each value in wdays must be between 0 and 6" if self.wdays.reject{|w| (0..6).member?(w)}.size > 0
+      self
     end
     
         
@@ -63,8 +75,9 @@ module RRSchedule
           end
         end
       end until @teams == initial_order && current_cycle==self.cycles
-      @teams.delete(:dummy)
-      slice(all_games)      
+      #@teams.delete(:dummy)
+      slice(all_games)
+      self
     end
 
 
@@ -83,7 +96,7 @@ module RRSchedule
         res << gd.strftime("%Y-%m-%d") + "\n"
         res << "==========\n"
         games.each do |g|
-          res << "#{g.team_a.to_s} VS #{g.team_b.to_s} on playing surface #{g.playing_surface} at #{g.game_time}\n"
+          res << "#{g.team_a.to_s} VS #{g.team_b.to_s} on playing surface #{g.playing_surface} at #{g.game_time.strftime("%I:%M %p")}\n"
         end
         res << "\n"
       end
@@ -102,24 +115,40 @@ module RRSchedule
       gms.flatten
     end
 
+    #TODO: returns true if the generated schedule is a valid round-robin (for testing purpose)
+    def round_robin?
+    
+      #each round-robin round should contains n-1 games where n is the nbr of teams (:dummy included if odd)
+      return false if self.rounds.size != (@teams.size*self.cycles)-self.cycles
+      
+      #check if each team plays the same number of games against each other
+      self.teams.each do |t1|                      
+        self.teams.reject{|t| t == t1}.each do |t2|
+          return false unless self.face_to_face(t1,t2).size == self.cycles || [t1,t2].include?(:dummy)
+        end
+      end
+      return true
+    end
+    
     private  
 
     def teams=(arr)
       @teams = arr.clone
-      @teams << :dummy if arr.size.odd?
+      raise ":dummy is a reserved team name. Please use something else" if @teams.member?(:dummy)
+      raise "at least 2 teams are required" if @teams.size == 1   
+      @teams << :dummy if @teams.size.odd?
     end
     
     #Let's slice our games according to our physical constraints
     def slice(games)
       res={}    
       slices = games.each_slice(games_per_day)
-      wdays_stack = self.wdays.clone
-            
+      wdays_stack = self.wdays.clone     
       cur_date = self.start_date
       slices.each_with_index do |slice,i|
         gt_stack = self.game_times.clone
         ps_stack = self.playing_surfaces.clone
-        wdays_stack=self.wdays.clone if wdays_stack.empty?        
+        wdays_stack = self.wdays.clone if wdays_stack.empty?
 
         cur_wday = wdays_stack.shift        
         cur_date = next_game_date(cur_date,cur_wday)
@@ -138,6 +167,8 @@ module RRSchedule
           gt_stack = self.game_times.clone if gt_stack.empty?          
           ps_stack = self.playing_surfaces.clone if ps_stack.empty?                              
         end
+        
+        res[cur_date] = res[cur_date].sort_by {|g| [g.game_time,g.playing_surface]}
         cur_date += 1.day
       end
       @schedule = res        

data/test/test_rrschedule.rb

@@ -1,7 +1,123 @@
 require 'helper'
 
 class TestRrschedule < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
+  context "A Schedule instance" do  
+    should "have default values for every options" do
+      schedule = RRSchedule::Schedule.new
+      
+      assert schedule.teams.size > 2
+      assert_equal 1, schedule.cycles
+      assert schedule.game_times.respond_to?(:to_ary)
+      assert schedule.playing_surfaces.respond_to?(:to_ary)
+      assert schedule.start_date.respond_to?(:to_date)
+      assert schedule.shuffle_initial_order
+      assert schedule.wdays.select{|w| (0..6).member? w} == schedule.wdays
+      assert schedule.exclude_dates.empty?
+    end
+    
+    should "have a dummy team when team number is odd" do
+      schedule = RRSchedule::Schedule.new(
+        :teams => Array(1..9)
+      )
+      
+      assert schedule.teams.size == 10
+      assert schedule.teams.member?(:dummy), "There should always be a :dummy team when the nbr of teams is odd"
+    end
+    
+    should "not have a dummy team when team number is even" do
+      schedule = RRSchedule::Schedule.new(
+        :teams => Array(1..6)
+      )
+      
+      assert schedule.teams.size == 6
+      assert !schedule.teams.member?(:dummy), "There should never be a :dummy team when the nbr of teams is even"
+    end
+    
+    should "not have a team named :dummy in the initial array" do
+      assert_raise RuntimeError do
+        schedule = RRSchedule::Schedule.new(
+          :teams => Array(1..4) << :dummy
+        )
+      end
+    end
+    
+    should "not have game times that cannot convert to valid DateTime objects" do
+      assert_raise RuntimeError do
+        schedule = RRSchedule::Schedule.new(
+          :teams => Array(1..4),
+          :game_times => ["10:00 AM", "13:00", "bonjour"]
+        )
+      end      
+    end
+    
+    should "not have wdays that are not between 0 and 6" do
+      assert_raise RuntimeError do
+        schedule = RRSchedule::Schedule.new(
+          :wdays => [2,7]
+        )
+      end      
+    end
+    
+    should "automatically convert game times and playing surface to arrays" do
+      schedule = RRSchedule::Schedule.new(
+        :teams => Array(1..4),
+        :game_times => "10:00 AM",
+        :playing_surfaces => "the only one"
+      )
+      
+      assert_equal [DateTime.parse("10:00 AM")], schedule.game_times
+      assert_equal ["the only one"], schedule.playing_surfaces
+    end
+    
+    should "have at least one team specified" do
+      assert_raise RuntimeError do
+        schedule = RRSchedule::Schedule.new(:teams => [1])      
+      end
+    end
+    
+    should "have default teams if non was specified" do
+      schedule = RRSchedule::Schedule.new
+      assert schedule.teams.size > 1
+    end    
   end
+  
+  context "A generated schedule with an odd number of teams" do
+    setup do
+      @s = RRSchedule::Schedule.new(
+        :teams => %w(a b c d e f g h i j l),
+        :playing_surfaces => %w(one two),
+        :game_times => ["10:00 AM", "13:00 PM"]
+      ).generate
+    end  
+    
+    should "be a valid round-robin" do
+      assert @s.round_robin?
+    end
+    
+    should "not have any :dummy teams in the schedule" do
+      assert @s.gamedays.collect{|gd,games| games}.flatten.select{
+        |g| [g.team_a,g.team_b].include?(:dummy)
+      }.size == 0
+    end
+  end
+  
+  context "A generated schedule with an even number of teams" do
+    setup do
+      @s = RRSchedule::Schedule.new(
+        :teams => %w(a b c d e f g h i j l m),
+        :playing_surfaces => %w(one two),
+        :game_times => ["10:00 AM", "13:00 PM"]
+      ).generate
+    end  
+    
+    should "be a valid round-robin" do
+      assert @s.round_robin?
+    end
+    
+    should "not have any :dummy teams in the schedule" do
+      assert @s.gamedays.collect{|gd,games| games}.flatten.select{
+        |g| [g.team_a,g.team_b].include?(:dummy)
+      }.size == 0
+    end
+  end  
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rrschedule
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - flamontagne
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-08 00:00:00 -05:00
+date: 2010-11-09 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,20 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
 description: This gem automate the process of creating a round-robin sport schedule.
 email: flamontagne@azanka.ca
 executables: []
@@ -86,5 +100,5 @@ signing_key:
 specification_version: 3
 summary: Round-Robin schedule generator
 test_files: 
-- test/test_rrschedule.rb
 - test/helper.rb
+- test/test_rrschedule.rb