rrschedule 0.1.4 → 0.1.5

data/README.rdoc

@@ -86,10 +86,10 @@ and will start a new round right after.
   end
 
 === Iterate through schedule
-  schedule.gamedays.each do |gd,games|
-    puts gd
+  schedule.gamedays.each do |gd|
+    puts gd.date
     puts "===================="
-    games.each do |g|
+    gd.games.each do |g|
       puts g.team_a.to_s + " Vs " + g.team_b.to_s + " on playing surface ##{g.playing_surface} at #{g.game_time}"     
     end
     puts "\n"

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.5

data/lib/rrschedule.rb

@@ -5,15 +5,16 @@ require 'active_support'
 module RRSchedule
   class Schedule
     attr_accessor :playing_surfaces, :game_times, :cycles, :wdays, :start_date, :exclude_dates, :shuffle_initial_order
-    attr_reader :teams, :rounds
+    attr_reader :teams, :rounds, :gamedays
 
     def initialize(params={})
+      @gamedays = []
       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 = Array(params[:game_times]).empty? ? ["7:00 PM", "9:00 PM"] : Array(params[:game_times])
-      self.game_times.collect! do |gt| 
+      self.game_times.collect! do |gt|
         begin
           DateTime.parse(gt) 
         rescue
@@ -21,7 +22,7 @@ module RRSchedule
         end
       end
       
-      self.shuffle_initial_order = params[:shuffle_initial_order] || true
+      self.shuffle_initial_order = params[:shuffle_initial_order].nil? ? true : params[:shuffle_initial_order]
       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])
@@ -83,41 +84,37 @@ module RRSchedule
 
     def face_to_face(team_a,team_b)
       res=[]
-      self.gamedays.each do |gd,games|
-        res << games.select {|g| (g.team_a == team_a && g.team_b == team_b) || (g.team_a == team_b && g.team_b == team_a)}
+      self.gamedays.each do |gd|
+        res << gd.games.select {|g| (g.team_a == team_a && g.team_b == team_b) || (g.team_a == team_b && g.team_b == team_a)}
       end
       res.flatten
     end
     
     def to_s
       res = ""
-      res << "#{@schedule.keys.size.to_s} gamedays\n"    
-      @schedule.sort.each do |gd,games|
-        res << gd.strftime("%Y-%m-%d") + "\n"
+      res << "#{self.gamedays.size.to_s} gamedays\n"    
+      self.gamedays.each do |gd|
+        res << gd.date.strftime("%Y-%m-%d") + "\n"
         res << "==========\n"
-        games.each do |g|
+        gd.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.strftime("%I:%M %p")}\n"
         end
         res << "\n"
       end
       res
     end
-    
-    def gamedays
-      @schedule.sort
-    end        
-    
-    def by_team(team)
+            
+    #TODO: should return either a Schedule instance or a TeamSchedule instance (this class doesn't exist yet)
+    def by_team(team)      
       gms=[]
-      self.gamedays.each do |gd,games|
-        gms << games.select{|g| g.team_a == team || g.team_b == team}
+      self.gamedays.each do |gd|
+        gms << gd.games.select{|g| g.team_a == team || g.team_b == team}                
       end
       gms.flatten
     end
 
-    #TODO: returns true if the generated schedule is a valid round-robin (for testing purpose)
-    def round_robin?
-    
+    #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
       
@@ -130,48 +127,48 @@ module RRSchedule
       return true
     end
     
-    private  
-
     def teams=(arr)
       @teams = arr.clone
       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
+        
+    private      
+    #Slice games according to playing surfaces and game times
     def slice(games)
-      res={}    
       slices = games.each_slice(games_per_day)
       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
+        gt_stack = self.game_times.clone.sort_by{rand}
+        ps_stack = self.playing_surfaces.clone.sort_by{rand}
         wdays_stack = self.wdays.clone if wdays_stack.empty?
 
         cur_wday = wdays_stack.shift        
         cur_date = next_game_date(cur_date,cur_wday)
         cur_gt = gt_stack.shift
         
-        res[cur_date] = []
+        gameday = Gameday.new(:date => cur_date)
+        
         slice.each_with_index do |g,game_index|          
           cur_ps = ps_stack.shift
-          res[cur_date] << Game.new(
+          gameday.games << Game.new(
                             :team_a => g[:team_a], 
                             :team_b => g[:team_b], 
                             :playing_surface => cur_ps, 
                             :game_time => cur_gt, 
                             :game_date => cur_date)
+          
           cur_gt = gt_stack.shift if ps_stack.empty?            
           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]}
+        gameday.games = gameday.games.sort_by {|g| [g.game_time,g.playing_surface]}
+        self.gamedays << gameday
         cur_date += 1.day
       end
-      @schedule = res        
     end
     
     def next_game_date(dt,wday)
@@ -183,7 +180,17 @@ module RRSchedule
       self.playing_surfaces.size * self.game_times.size
     end
   end  
-  
+
+  class Gameday
+    attr_accessor :date, :games
+    
+    def initialize(params)
+      self.date = params[:date]
+      self.games = params[:games] || []
+    end
+    
+  end
+    
   class Game
     attr_accessor :team_a, :team_b, :playing_surface, :game_time, :game_date
     
@@ -201,7 +208,7 @@ module RRSchedule
     
     def initialize(params={})
       self.round = params[:round]
-      self.games = params[:games]
+      self.games = params[:games] || []
     end
   end
 end

data/test/test_rrschedule.rb

@@ -15,7 +15,7 @@ class TestRrschedule < Test::Unit::TestCase
       assert schedule.exclude_dates.empty?
     end
     
-    should "have a dummy team when team number is odd" do
+    should "have a dummy team when number of teams is odd" do
       schedule = RRSchedule::Schedule.new(
         :teams => Array(1..9)
       )
@@ -24,7 +24,7 @@ class TestRrschedule < Test::Unit::TestCase
       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
+    should "not have a dummy team when number of teams is even" do
       schedule = RRSchedule::Schedule.new(
         :teams => Array(1..6)
       )
@@ -69,7 +69,7 @@ class TestRrschedule < Test::Unit::TestCase
       assert_equal ["the only one"], schedule.playing_surfaces
     end
     
-    should "have at least one team specified" do
+    should "have at least two teams" do
       assert_raise RuntimeError do
         schedule = RRSchedule::Schedule.new(:teams => [1])      
       end
@@ -81,6 +81,25 @@ class TestRrschedule < Test::Unit::TestCase
     end    
   end
   
+  context "Any valid schedule" 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"]
+      )
+    end
+    
+    should "have gamedays that respect the wdays attribute" do
+      @s.wdays = [3,5]
+      @s.generate
+
+      @s.gamedays.each do |gd|
+        assert [3,5].include?(gd.date.wday), "wday is #{gd.date.wday.to_s} but should be 3 or 5"
+      end
+    end
+  end  
+  
   context "A generated schedule with an odd number of teams" do
     setup do
       @s = RRSchedule::Schedule.new(
@@ -94,8 +113,8 @@ class TestRrschedule < Test::Unit::TestCase
       assert @s.round_robin?
     end
     
-    should "not have any :dummy teams in the schedule" do
-      assert @s.gamedays.collect{|gd,games| games}.flatten.select{
+    should "not have any :dummy teams in the final schedule" do
+      assert @s.gamedays.collect{|gd| gd.games}.flatten.select{
         |g| [g.team_a,g.team_b].include?(:dummy)
       }.size == 0
     end
@@ -114,10 +133,10 @@ class TestRrschedule < Test::Unit::TestCase
       assert @s.round_robin?
     end
     
-    should "not have any :dummy teams in the schedule" do
-      assert @s.gamedays.collect{|gd,games| games}.flatten.select{
+    should "not have any :dummy teams in the final schedule" do
+      assert @s.gamedays.collect{|gd| gd.games}.flatten.select{
         |g| [g.team_a,g.team_b].include?(:dummy)
       }.size == 0
-    end
-  end  
+    end    
+  end    
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rrschedule
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 1
-  - 4
-  version: 0.1.4
+  - 5
+  version: 0.1.5
 platform: ruby
 authors: 
 - flamontagne
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-09 00:00:00 -05:00
+date: 2010-11-10 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -100,5 +100,5 @@ signing_key:
 specification_version: 3
 summary: Round-Robin schedule generator
 test_files: 
-- test/helper.rb
 - test/test_rrschedule.rb
+- test/helper.rb