rrschedule 0.2.2 → 0.2.3

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

data/lib/rrschedule.rb

@@ -89,7 +89,7 @@ module RRSchedule
       self.gamedays.each do |gd|
         res << gd.date.strftime("%Y-%m-%d") + "\n"
         res << "==========\n"
-        gd.games.each do |g|
+        gd.games.sort{|g1,g2| g1.gt == g2.gt ? g1.ps <=> g2.ps : g1.gt <=> g2.gt}.each do |g|
           res << "#{g.ta.to_s} VS #{g.tb.to_s} on playing surface #{g.ps} at #{g.gt.strftime("%I:%M %p")}\n"
         end
         res << "\n"
@@ -129,42 +129,19 @@ module RRSchedule
     end
 
     #Dispatch games according to available playing surfaces and game times
-    #The flat schedule contains "place holders" for the actual games. Each row contains
-    #a game date, a game time and a playing surface. We then process our rounds one by one
-    #and we put each matchup in the next available slot of the flat schedule
     def dispatch_games(rounds)
-      teams_day = {}
-      flat_schedule = generate_flat_schedule
-
       rounds_copy =  Marshal.load(Marshal.dump(rounds)) #deep clone
-      cur_flight_index = i = 0
+      cur_flight_index = 0
 
       while !rounds_copy.flatten.empty? do
         cur_round = rounds_copy[cur_flight_index].shift
-
         #process the next round in the current flight
         if cur_round
-          cur_round.games.shuffle.each do |game|
-            unless [game.team_a,game.team_b].include?(:dummy)
-              if teams_day[flat_schedule[i][:gamedate]] && (teams_day[flat_schedule[i][:gamedate]].include?(game.team_a) || teams_day[flat_schedule[i][:gamedate]].include?(game.team_b))
-                #team is already playing this day. This can happen if we have flights with different number of teams in it.
-                gamedate = flat_schedule[i][:gamedate]
-                while flat_schedule[i] && flat_schedule[i][:gamedate] == gamedate do
-                  i += 1
-                end
-              end
-
-              flat_schedule[i][:team_a] = game.team_a
-              flat_schedule[i][:team_b] = game.team_b
-              teams_day[flat_schedule[i][:gamedate]] ||= []
-              teams_day[flat_schedule[i][:gamedate]] << game.team_a
-              teams_day[flat_schedule[i][:gamedate]] << game.team_b
-              i += 1
-            end
+          cur_round.games.each do |game|
+            dispatch_game(game) unless [game.team_a,game.team_b].include?(:dummy)
           end
         end
 
-
         if cur_flight_index == @flights.size-1
           cur_flight_index = 0
         else
@@ -172,8 +149,8 @@ module RRSchedule
         end
       end
 
-      #We group our flat schedule by gameday
-      s=flat_schedule.group_by{|fs| fs[:gamedate]}.sort
+      #We group our schedule by gameday
+      s=@schedule.group_by{|fs| fs[:gamedate]}.sort
       s.each do |gamedate,gms|
         games = []
         gms.each do |gm|
@@ -186,57 +163,113 @@ module RRSchedule
         end
         self.gamedays << Gameday.new(:date => gamedate, :games => games)
       end
-      self.gamedays.each { |gd| gd.games.reject! {|g| g.team_a.nil?}}
     end
 
 
-    def generate_flat_schedule
-      flat_schedule = []
-      games_left = max_games_per_day = day_game_ctr = rule_ctr = 0
-
-      #determine first rule based on the nearest gameday
-      cur_rule  = @rules.select{|r| r.wday >= self.start_date.wday}.first || @rules.first
-      cur_rule_index = @rules.index(cur_rule)
-      cur_date = next_game_date(self.start_date,cur_rule.wday)
-
-      @flights.each do |flight|
-        games_left += @cycles * (flight.include?(:dummy) ? ((flight.size-1)/2.0)*(flight.size-2) : (flight.size/2)*(flight.size-1))
-        max_games_per_day += (flight.include?(:dummy) ? ((flight.size-2)/2.0) : (flight.size-1)/2.0).ceil
+    def dispatch_game(game)
+      @cur_rule ||= @rules.select{|r| r.wday >= self.start_date.wday}.first || @rules.first
+      @cur_rule_index ||= @rules.index(@cur_rule)
+
+      @gt_stack ||= @cur_rule.gt.clone
+      @ps_stack ||= @cur_rule.ps.clone.shuffle
+
+      @cur_gt ||= @gt_stack.shift
+      @cur_ps ||= @ps_stack.shift
+      @cur_date ||= next_game_date(self.start_date,@cur_rule.wday)
+      @schedule ||= []
+
+      #if one of the team has already plays at this gamedate, we change rule
+      if @schedule.size>0
+        games_this_date = @schedule.select{|v| v[:gamedate] == @cur_date}
+        if games_this_date.select{|g| [game.team_a,game.team_b].include?(g[:team_a]) || [game.team_a,game.team_b].include?(g[:team_b])}.size >0
+          @cur_rule_index = (@cur_rule_index < @rules.size-1) ? @cur_rule_index+1 : 0
+          @cur_rule = @rules[@cur_rule_index]
+          @gt_stack = @cur_rule.gt.clone
+          @ps_stack = @cur_rule.ps.clone.shuffle
+          @cur_gt = @gt_stack.shift
+          @cur_ps = @ps_stack.shift
+          @cur_date = next_game_date(@cur_date+=1,@cur_rule.wday)
+        end
       end
 
+      @schedule << {:team_a => game.team_a, :team_b => game.team_b, :gamedate => @cur_date, :ps => @cur_ps, :gt => @cur_gt}
 
-      #while there are games to process...
-      while games_left > 0 do
+      if !@ps_stack.empty?
+        @cur_ps = @ps_stack.shift
+      else
+        if !@gt_stack.empty?
+          @cur_gt = @gt_stack.shift
+          @ps_stack = @cur_rule.ps.clone.shuffle; @cur_ps = @ps_stack.shift
+        else
+          #PS and GT stack empty... we go to the next rule
+          if @cur_rule_index < @rules.size-1
+            @cur_rule_index += 1
+            #Go to the next date (except if the new rule is for the same weekday)
+            @cur_date = next_game_date(@cur_date+=1,@cur_rule.wday) if @cur_rule.wday != @rules[@cur_rule_index].wday
+          else
+            @cur_rule_index = 0
+            @cur_date = next_game_date(@cur_date+=1,@cur_rule.wday)
+          end
+          @cur_rule = @rules[@cur_rule_index]
+          @gt_stack = @cur_rule.gt.clone; @cur_gt = @gt_stack.shift
+          @ps_stack = @cur_rule.ps.clone.shuffle; @cur_ps = @ps_stack.shift
+        end
+      end
 
-        #add all possible games based on the current rule
-        cur_rule.gt.each do |gt|
-          cur_rule.ps.each do |ps|
+    end
 
-            #if there are more physical resources (playing surfaces and game times) for a given day than
-            #we need, we don't use them all (or else some teams would play twice on a single day)
-            if day_game_ctr <= max_games_per_day-1
-              flat_schedule << {:gamedate => cur_date, :gt => gt, :ps => ps}
-              games_left -= 1; day_game_ctr += 1
-            end
-          end
+    def place_game(game)
+      @cur_rule ||= @rules.select{|r| r.wday >= self.start_date.wday}.first || @rules.first
+
+      @cur_rule_index ||= @rules.index(@cur_rule)
+      @cur_gt_index ||= 0
+      @cur_ps_index ||= 0
+
+      @cur_gt = @cur_rule.gt[@cur_gt_index]
+      @cur_ps = @cur_rule.ps[@cur_ps_index]
+      @cur_date ||= next_game_date(self.start_date,@cur_rule.wday)
+      @schedule ||= []
+
+      #if one of the team has already plays at this gamedate, we change rule
+      if @schedule.size>0
+        games_this_date = @schedule.select{|v| v[:gamedate] == @cur_date}
+        if games_this_date.select{|g| [game.team_a,game.team_b].include?(g[:team_a]) || [game.team_a,game.team_b].include?(g[:team_b])}.size >0
+          @cur_rule_index = (@cur_rule_index < @rules.size-1) ? @cur_rule_index+1 : 0
+          @cur_rule = @rules[@cur_rule_index]
+          @cur_ps_index=0
+          @cur_gt_index=0
+          @cur_ps = @cur_rule.ps.first
+          @cur_gt = @cur_rule.gt.first
+          @cur_date = next_game_date(@cur_date+=1,@cur_rule.wday)
         end
+      end
 
-        last_rule = cur_rule
-        last_date = cur_date
+      @schedule << {:team_a => game.team_a, :team_b => game.team_b, :gamedate => @cur_date, :ps => @cur_ps, :gt => @cur_gt}
 
-        #Advance to the next rule (if we're at the last one, we go back to the first)
-        cur_rule_index = (cur_rule_index == @rules.size-1) ? 0 : cur_rule_index + 1
-        cur_rule = @rules[cur_rule_index]
+      if @cur_ps_index < @cur_rule.ps.size-1
+        @cur_ps_index += 1
+      else
+        @cur_ps_index = 0
 
-        #Go to the next date (except if the new rule is for the same weekday)
-        if cur_rule.wday != last_rule.wday || cur_rule_index == 0
-          cur_date = next_game_date(cur_date+=1,cur_rule.wday)
-          day_game_ctr = 0
+        if @cur_gt_index < @cur_rule.gt.size-1
+          @cur_gt_index += 1
+        else
+          @cur_gt_index = 0
+
+          if @cur_rule_index < @rules.size-1
+            @cur_rule_index += 1
+            #Go to the next date (except if the new rule is for the same weekday)
+            @cur_date = next_game_date(@cur_date+=1,@cur_rule.wday) if @cur_rule.wday != @rules[@cur_rule_index].wday
+          else
+            @cur_rule_index = 0
+            @cur_date = next_game_date(@cur_date+=1,@cur_rule.wday)
+          end
+          @cur_rule = @rules[@cur_rule_index]
         end
       end
-      flat_schedule
     end
 
+
     #get the next gameday
     def next_game_date(dt,wday)
       dt += 1 until wday == dt.wday && !self.exclude_dates.include?(dt)

data/test/test_rrschedule.rb

@@ -142,8 +142,8 @@ class TestRrschedule < Test::Unit::TestCase
       @s = Schedule.new
       @s.teams = [%w(a1 a2 a3 a4 a5 a6 a7 a8), %w(b1 b2 b3 b4 b5 b6 b7 b8)]
       @s.rules = [
-        Rule.new(:wday => 4, :gt => ["7:00PM"], :ps => %w(field#1 field#2)),
-        Rule.new(:wday => 4, :gt => ["9:00PM"], :ps => %w(field#1 field#2 field#3))
+        Rule.new(:wday => 4, :gt => ["7:00PM"], :ps => %w(field1 field2)),
+        Rule.new(:wday => 4, :gt => ["9:00PM"], :ps => %w(field1 field2 field3))
       ]
       @s.start_date = Date.parse("2011/01/27")
       @s.generate
@@ -158,11 +158,11 @@ class TestRrschedule < Test::Unit::TestCase
         #the last one because it might not be full (round-robin over)
         if i<@s.gamedays.size-1
           assert_equal 5, gd.games.size
-          assert_equal 1, gd.games.select{|g| g.game_time == DateTime.parse("7:00PM") && g.playing_surface == "field#1"}.size
-          assert_equal 1, gd.games.select{|g| g.game_time == DateTime.parse("7:00PM") && g.playing_surface == "field#2"}.size
-          assert_equal 1, gd.games.select{|g| g.game_time == DateTime.parse("9:00PM") && g.playing_surface == "field#1"}.size
-          assert_equal 1, gd.games.select{|g| g.game_time == DateTime.parse("9:00PM") && g.playing_surface == "field#2"}.size
-          assert_equal 1, gd.games.select{|g| g.game_time == DateTime.parse("9:00PM") && g.playing_surface == "field#3"}.size
+          assert_equal 1, gd.games.select{|g| g.game_time == DateTime.parse("7:00PM") && g.playing_surface == "field1"}.size
+          assert_equal 1, gd.games.select{|g| g.game_time == DateTime.parse("7:00PM") && g.playing_surface == "field2"}.size
+          assert_equal 1, gd.games.select{|g| g.game_time == DateTime.parse("9:00PM") && g.playing_surface == "field1"}.size
+          assert_equal 1, gd.games.select{|g| g.game_time == DateTime.parse("9:00PM") && g.playing_surface == "field2"}.size
+          assert_equal 1, gd.games.select{|g| g.game_time == DateTime.parse("9:00PM") && g.playing_surface == "field3"}.size
           cur_date += 7
         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
   - 2
-  - 2
-  version: 0.2.2
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - flamontagne
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-17 00:00:00 -05:00
+date: 2011-02-18 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency