rrschedule 0.1.8 → 0.2.0

data/README.markdown

@@ -0,0 +1,65 @@
+# RRSchedule #
+
+RRSchedule makes it easier to generate round-robin schedules for sport leagues.
+
+It takes into consideration the number of available playing surfaces and game times and split
+games into gamedays that respect these contraints.
+
+## Installation ##
+    gem install rrschedule
+    require 'rrschedule'
+
+## Prepare the schedule ##
+    schedule=RRSchedule::Schedule.new(
+      #array of teams that will compete against each other. If you group teams into multiple flights (divisions),
+      #a separate round-robin is generated in each of them but the "physical constraints" are shared
+      :teams => [
+        %w(A1 A2 A3 A4 A5 A6 A7 A8),
+        %w(B1 B2 B3 B4 B5 B6 B7 B8)
+      ],
+
+      #Setup some scheduling rules
+      :rules => [
+        RRSchedule::Rule.new(:wday => 3, :gt => ["7:00PM","9:00PM"], :ps => ["field #1", "field #2"]),
+        RRSchedule::Rule.new(:wday => 5, :gt => ["7:00PM"], :ps => ["field #1"])
+      ],
+          
+      #First games are played on...
+      :start_date => Date.parse("2010/10/13"),
+      
+      #array of dates to exclude
+      :exclude_dates => [Date.parse("2010/11/24"),Date.parse("2010/12/15")],
+                        
+      #Number of times each team must play against each other (default is 1)
+      :cycles => 1,
+       
+      #Shuffle team order before each cycle. Default is true
+      :shuffle => true
+    )
+
+## Generate the schedule ##
+    schedule.generate
+  
+## Playing with the output ##
+
+### human readable schedule ###
+    puts schedule.to_s
+
+### Iterate through schedule ###
+    schedule.gamedays.each do |gd|
+      puts gd.date.strftime("%Y/%m/%d")
+      puts "===================="
+      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.strftime("%I:%M %p")}"     
+      end
+      puts "\n"
+    end
+
+### Display each round of the round-robin(s) without any date/time or playing location info ###
+    puts s.rounds.collect{|r| r.to_s}
+
+## Issues / Other ##
+
+Hope this gem will be useful to some people!
+
+You can read my [blog](http://www.rubyfleebie.com)

data/VERSION

@@ -1 +1 @@
-0.1.8
+0.2.0

data/branches_info.markdown

@@ -0,0 +1,55 @@
+# Branches summary
+
+The objective of this file is to share the intention behind every new branches that are created for RRSchedule. Since each branch
+generally represents a "development effort", I think it is useful to describe and explain them.
+
+## Rules and multiple round-robins (branch created on 2011/01/21)
+
+### Rules
+
+The idea behind having "rules" is to allow more flexibility in the schedule generation.
+
+At the moment, we can tell RRSchedule that the games are played (for example) every monday and wednesday at 7:00PM and 9:00PM on four different
+playing surfaces. But what if games played on monday are held at 7:00PM while games played on wednesday are held at 7:00PM and 9:00PM?
+You just cannot configure it this way at the moment. And what if on monday every playing surfaces are available while only 1 is available on wednesday?
+This is why I had the idea of replacing the current "one size fits all" system with a more flexible system.
+
+Thus, we will be able to have rules like:
+
+    Day of week | Game Time | playing surfaces   |
+    Monday      | 7:00PM    | Field #1, Field #2 |
+    Wednesday   | 7:00PM    | Field #1           |
+    Wednesday   | 9:00PM    | Field #1
+
+In the code it might look something like this:
+
+    schedule.rules << Rule.new(:wday => 1, :gt => "7:00PM", :ps => ["Field #1", "Field #2"])
+    schedule.rules << Rule.new(:wday => 3, :gt => "7:00PM", :ps => "Field #1")
+    schedule.rules << Rule.new(:wday => 3, :gt => "9:00PM", :ps => "Field #1")
+
+    schedule.generate
+
+    ...
+
+### Multiple round-robins
+
+The other development in this branch involves the possibility to create multiple round-robins in the same method call while sharing the same
+physical constraints (game times and playing surfaces)
+
+Several sport leagues use a "division" system where teams are seeded in different groups based on their performance. Each group plays
+a round-robin *inside* its own division. Suppose a league of 4 divisions containing 8 teams each. A1 will play against A2, A3 and so on but not
+against B1, C3 or D6. What we need in this case is 4 different round-robins. However, these 4 round-robins share the same playing surfaces and
+game times.
+
+In other words, you will be able to do something like this:
+
+    schedule.teams = [
+      [A1,A2,A3,A4,A5,A6,A7,A8],
+      [B1,B2,B3,B4,B5,B6,B7,B8],
+      [C1,C2,C3,C4,C5,C6,C7,C8],
+      [D1,D2,D3,D4,D5,D6,D7,D8]
+    ]
+
+    schedule.rules << Rule.new(
+      ... #same rules apply for all 32 teams
+    )

data/lib/rrschedule.rb

@@ -3,155 +3,89 @@
 ############################################################################################################################
 module RRSchedule
   class Schedule
-    attr_reader :playing_surfaces, :game_times, :cycles, :wdays, :start_date, :exclude_dates, 
-                :shuffle_initial_order, :optimize, :teams, :rounds, :gamedays
-    
-    
-    #Array of teams that will compete against each other. You can pass it any kind of object
-    def teams=(arr)
-      @teams = arr ? arr.clone : [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
-      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
-      raise "teams have to be unique" if @teams.uniq.size < @teams.size  
-      @teams << :dummy if @teams.size.odd?
-    end
-    
-    #Array of available playing surfaces. You can pass it any kind of object
-    def playing_surfaces=(ps)
-      @playing_surfaces = Array(ps).empty? ? ["Surface A", "Surface B"] : Array(ps)
-    end
-    
-    #Number of times each team plays against each other
-    def cycles=(cycles)
-      @cycles = cycles || 1
-    end
-    
-    #Array of game times where games are played. Must be valid DateTime objects in the string form
-    def game_times=(gt)
-      @game_times =  Array(gt).empty? ? ["7:00 PM", "9:00 PM"] : Array(gt)
-      @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      
-    end
-    
-    #Setting this to true will fill all the available playing surfaces and game times for a given gameday no matter if
-    #one team has to play several games on the same gameday. Setting it to false make sure that teams won't play
-    #more than one game per day. 
-    def optimize=(opt)
-      @optimize = opt.nil? ? true : opt
-    end
-    
-    #Shuffle the team order at the beginning of every cycles.
-    def shuffle_initial_order=(shuffle)
-      @shuffle_initial_order = shuffle.nil? ? true : shuffle
-    end
-    
-    #Array of dates without games
-    def exclude_dates=(dates)
-      @exclude_dates=dates || []
-    end
-    
-    #When the season starts? Since we generate the game dates based on weekdays, you need to pass it
-    #a start date in the correct timezone to get accurate game dates for the whole season. Otherwise
-    #you might
-    def start_date=(date)
-      @start_date=date || Date.today
-    end
-    
-    #Array of weekdays where games are played (0 is sunday)
-    def wdays=(wdays)
-      @wdays = Array(wdays).empty? ? [1] : Array(wdays)      
-      raise "each value in wdays must be between 0 and 6" if @wdays.reject{|w| (0..6).member?(w)}.size > 0
-    end
-    
+    attr_reader :flights, :rounds, :gamedays
+    attr_accessor :teams, :rules, :cycles, :start_date, :exclude_dates,:shuffle
+
     def initialize(params={})
       @gamedays = []
-      self.teams = params[:teams]
-      self.playing_surfaces = params[:playing_surfaces]
-      self.cycles = params[:cycles]      
-      self.game_times = params[:game_times]
-      self.optimize = params[:optimize]
-      self.shuffle_initial_order = params[:shuffle_initial_order]
-      self.exclude_dates = params[:exclude_dates]
-      self.start_date = params[:start_date]
-      self.wdays = params[:wdays] 
+      self.teams = params[:teams] if params[:teams]
+      self.cycles = params[:cycles] || 1
+      self.shuffle = params[:shuffle].nil? ? true : params[:shuffle]
+      self.exclude_dates = params[:exclude_dates] || []
+      self.start_date = params[:start_date] || Date.today
+      self.rules = params[:rules] || []
       self
     end
-    
-    
+
     #This will generate the schedule based on the various parameters
-    #TODO: consider refactoring with a recursive algorithm
     def generate(params={})
+      raise "You need to specify at least 1 team" if @teams.nil? || @teams.empty?
+      raise "You need to specify at least 1 rule" if @rules.nil? || @rules.empty?
+      arrange_flights
       @gamedays = []
       @rounds = []
-      @teams = @teams.sort_by{rand} if self.shuffle_initial_order
-      initial_order = @teams.clone
-      current_cycle = current_round = 0
-      all_games = []      
-            
-      #Cycle loop (A cycle is completed when every teams have played one game against each other)
-      begin
-        games = []
-        t = @teams.clone        
-        
-        #Round loop
-        while !t.empty? do
-          team_a = t.shift
-          team_b = t.reverse!.shift
-          t.reverse!
-                    
-          matchup = {:team_a => team_a, :team_b => team_b}
-          games << matchup; all_games << matchup
-        end
-                
-        current_round += 1
-        
-        @rounds ||= []
-        @rounds << Round.new( 
-                    :round => current_round,
-                    :games => games.collect { |g| Game.new( 
-                                                    :team_a => g[:team_a],
-                                                    :team_b => g[:team_b])
-                                            })
-        
-        reject_dummy = lambda {|g| g[:team_a] == :dummy || g[:team_b] == :dummy}
-        games.reject! {|g| reject_dummy.call(g)}
-        all_games.reject! {|g| reject_dummy.call(g)}
-          
-        @teams = @teams.insert(1,@teams.delete_at(@teams.size-1))
-        
-        #If we have completed a cycle
-        if @teams == initial_order
-          current_cycle += 1        
-          #Shuffle the teams at each cycle
-          if current_cycle <= self.cycles && self.shuffle_initial_order
-            @teams = @teams.sort_by{rand}
-            initial_order = @teams.clone
+
+      @flights.each_with_index do |teams,flight_id|
+        current_cycle = current_round = 0
+        teams = teams.sort_by{rand} if @shuffle
+
+        #loop to generate the whole round-robin(s) for the current flight
+        begin
+          t = teams.clone
+          games = []
+
+          #process one round
+          while !t.empty? do
+            team_a = t.shift
+            team_b = t.reverse!.shift
+            t.reverse!
+
+            matchup = {:team_a => team_a, :team_b => team_b}
+            games << matchup
           end
-        end
-      end until @teams == initial_order && current_cycle==self.cycles
+          #done processing round
 
-      slice(all_games)
-      self
-    end
+          current_round += 1
 
-    #returns an array of Game instances where team_a and team_b are facing each other
-    def face_to_face(team_a,team_b)
-      res=[]
-      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)}
+          #Team rotation
+          teams = teams.insert(1,teams.delete_at(teams.size-1))
+
+          #add the round in memory
+          @rounds ||= []
+          @rounds[flight_id] ||= []
+          @rounds[flight_id] << Round.new(
+            :round => current_round,
+            :flight => flight_id,
+            :games => games.collect { |g|
+              Game.new(
+                :team_a => g[:team_a],
+                :team_b => g[:team_b]
+              )
+            }
+          )
+          #done adding round
+
+          #have we completed a full round-robin for the current flight?
+          if current_round == teams.size-1
+            current_cycle += 1
+
+            if current_cycle < self.cycles
+              current_round = 0
+              teams = teams.sort_by{rand} if @shuffle
+            end
+          end
+
+        end until current_round == teams.size-1 && current_cycle==self.cycles
       end
-      res.flatten
+
+      dispatch_games(@rounds)
+      self
     end
-    
+
     #human readable schedule
     def to_s
       res = ""
-      res << "#{self.gamedays.size.to_s} gamedays\n"    
+      res << "#{self.gamedays.size.to_s} gamedays\n"
       self.gamedays.each do |gd|
         res << gd.date.strftime("%Y-%m-%d") + "\n"
         res << "==========\n"
@@ -163,92 +97,196 @@ module RRSchedule
       res
     end
 
-    #return an array of Game instances where 'team' is playing            
-    def by_team(team)      
-      gms=[]
-      self.gamedays.each do |gd|
-        gms << gd.games.select{|g| g.team_a == team || g.team_b == team}                
-      end
-      gms.flatten
-    end
-
     #returns true if the generated schedule is a valid round-robin (for testing purpose)
-    def round_robin?    
+    def round_robin?(flight_id=nil)
       #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
-      
+      return false if self.rounds[flight_id].size != (@flights[flight_id].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)
+      @flights[flight_id].each do |t1|
+        @flights[flight_id].reject{|t| t == t1}.each do |t2|
+          return false unless face_to_face(t1,t2).size == self.cycles || [t1,t2].include?(:dummy)
         end
       end
       return true
     end
-        
-    private      
-    #Slice games according to playing surfaces available and game times
-    def slice(games)
-      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.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
-        
-        gameday = Gameday.new(:date => cur_date)
-        
-        slice.each_with_index do |g,game_index|          
-          cur_ps = ps_stack.shift
-          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?                              
+
+    private
+
+    def arrange_flights
+      #a flight is a division where teams play round-robin against each other
+      @flights = Marshal.load(Marshal.dump(@teams)) #deep clone
+
+      #If teams aren't in flights, we create a single flight and put all teams in it
+      @flights = [@flights] unless @flights.first.respond_to?(:to_ary)
+
+      @flights.each_with_index do |flight,i|
+        raise ":dummy is a reserved team name. Please use something else" if flight.member?(:dummy)
+        raise "at least 2 teams are required" if flight.size < 2
+        raise "teams have to be unique" if flight.uniq.size < flight.size
+        @flights[i] << :dummy if flight.size.odd?
+      end
+    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)
+      flat_schedule = generate_flat_schedule
+
+      rounds_copy =  Marshal.load(Marshal.dump(rounds)) #deep clone
+      cur_flight_index = i = 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.each do |game|
+            unless [game.team_a,game.team_b].include?(:dummy)
+              flat_schedule[i][:team_a] = game.team_a
+              flat_schedule[i][:team_b] = game.team_b
+              i+=1
+            end
+          end
+        end
+
+
+        if cur_flight_index == @flights.size-1
+          cur_flight_index = 0
+        else
+          cur_flight_index += 1
+        end
+      end
+
+      #We group our flat schedule by gameday
+      s=flat_schedule.group_by{|fs| fs[:gamedate]}.sort
+      s.each do |gamedate,gms|
+        games = []
+        gms.each do |gm|
+          games << Game.new(
+            :team_a => gm[:team_a],
+            :team_b => gm[:team_b],
+            :playing_surface => gm[:ps],
+            :game_time => gm [:gt]
+          )
+        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
+      end
+
+      #process all games
+      while games_left > 0 do
+        cur_rule.gt.each do |gt|
+          cur_rule.ps.each do |ps|
+
+            #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
+        end
+
+        last_rule = cur_rule
+        last_date = cur_date
+
+        #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]
+
+        #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
         end
-        
-        gameday.games = gameday.games.sort_by {|g| [g.game_time,g.playing_surface]}
-        self.gamedays << gameday
-        cur_date += 1
       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)
       dt
     end
-    
-    #how many games can we play per day? 
-    def games_per_day
-      if self.teams.size/2 >= (self.playing_surfaces.size * self.game_times.size)
-        (self.playing_surfaces.size * self.game_times.size)
-      else
-        self.optimize ? (self.playing_surfaces.size * self.game_times.size) : self.teams.size/2
+
+    #return matchups between two teams
+    def face_to_face(team_a,team_b)
+      res=[]
+      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
-  end  
+  end
 
   class Gameday
     attr_accessor :date, :games
-    
+
     def initialize(params)
       self.date = params[:date]
       self.games = params[:games] || []
     end
-    
+
+  end
+
+  class Rule
+    attr_accessor :wday, :gt, :ps
+
+
+    def initialize(params)
+      self.wday = params[:wday]
+      self.gt = params[:gt]
+      self.ps = params[:ps]
+    end
+
+    def wday=(wday)
+      @wday = wday ? wday : 1
+      raise "Rule#wday must be between 0 and 6" unless (0..6).include?(@wday)
+    end
+
+    #Array of available playing surfaces. You can pass it any kind of object
+    def ps=(ps)
+      @ps = Array(ps).empty? ? ["Field #1", "Field #2"] : Array(ps)
+    end
+
+    #Array of game times where games are played. Must be valid DateTime objects in the string form
+    def gt=(gt)
+      @gt =  Array(gt).empty? ? ["7:00 PM"] : Array(gt)
+      @gt.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
+    end
+
+    def <=>(other)
+      self.wday == other.wday ?
+      DateTime.parse(self.gt.first.to_s) <=> DateTime.parse(other.gt.first.to_s) :
+      self.wday <=> other.wday
+    end
   end
-    
+
   class Game
     attr_accessor :team_a, :team_b, :playing_surface, :game_time, :game_date
     alias :ta :team_a
@@ -256,23 +294,37 @@ module RRSchedule
     alias :ps :playing_surface
     alias :gt :game_time
     alias :gd :game_date
-    
+
     def initialize(params={})
       self.team_a = params[:team_a]
       self.team_b = params[:team_b]
       self.playing_surface = params[:playing_surface]
-      self.game_time = params[:game_time]            
+      self.game_time = params[:game_time]
       self.game_date = params[:game_date]
     end
   end
-  
+
   class Round
-    attr_accessor :round, :games
-    
+    attr_accessor :round, :games,:flight
+
     def initialize(params={})
       self.round = params[:round]
+      self.flight = params[:flight]
       self.games = params[:games] || []
     end
+
+    def to_s
+      str = "FLIGHT #{@flight.to_s} - Round ##{@round.to_s}\n"
+      str += "=====================\n"
+
+      self.games.each do |g|
+        if [g.team_a,g.team_b].include?(:dummy)
+          str+= g.team_a == :dummy ? g.team_b.to_s : g.team_a.to_s + " has a BYE\n"
+        else
+          str += g.team_a.to_s + " Vs " + g.team_b.to_s + "\n"
+        end
+      end
+      str += "\n"
+    end
   end
 end
-

data/test/test_rrschedule.rb

@@ -1,163 +1,178 @@
 require 'helper'
-
 class TestRrschedule < Test::Unit::TestCase
-  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.is_a?(Date)
-      assert schedule.shuffle_initial_order
-      assert schedule.optimize
-      assert schedule.wdays.select{|w| (0..6).member? w} == schedule.wdays
-      assert schedule.exclude_dates.empty?
-    end
-    
-    should "have a dummy team when number of teams 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 number of teams 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
+  include RRSchedule
+  context "new instance without params" do
+    setup {@s= Schedule.new}
+    should "have default values for some options" do
+      assert_equal 1, @s.cycles
+      assert @s.shuffle
+      assert_equal Date.today, @s.start_date
+      assert_equal [], @s.exclude_dates
     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 two teams" do
-      assert_raise RuntimeError do
-        schedule = RRSchedule::Schedule.new(:teams => [1])      
-      end
+  end
+
+  context "no teams" do
+    setup {@s = Schedule.new(:rules => [Rule.new(:wday => 1, :gt => ["7:00PM"], :ps => %w(one two))])}
+    should "raise an exception" do
+      exception = assert_raise(RuntimeError){@s.generate}
+      assert_equal "You need to specify at least 1 team", exception.message
+    end
+  end
+
+  context "no flight" do
+    setup{@s=Schedule.new(:teams => %w(1 2 3 4 5 6), :rules => some_rules)}
+    should "be wrapped into a single flight in the normalized array" do
+      @s.generate
+      assert_equal [%w(1 2 3 4 5 6)], @s.flights
+    end
+
+    should "not modify the original array" do
+      assert_equal %w(1 2 3 4 5 6), @s.teams
+    end
+  end
+
+  context "odd number of teams without flight" do
+    setup {@s=Schedule.new(:teams => %w(1 2 3 4 5),:rules => some_rules).generate}
+    should "add a dummy competitor in the created flight" do
+      assert_equal 1, @s.flights.size
+      assert_equal 6, @s.flights.first.size
+      assert @s.flights.first.include?(:dummy)
+    end
+
+    should "not modify the original array" do
+      assert_equal 5, @s.teams.size
+      assert !@s.teams.include?(:dummy)
     end
-    
-    should "have default teams if non was specified" do
-      schedule = RRSchedule::Schedule.new
-      assert schedule.teams.size > 1
-    end    
-    
-    should "not have a team that is specified twice" do
-      assert_raise RuntimeError do
-        schedule = RRSchedule::Schedule.new(:teams => %w(a a b c d e f g h i))
-      end
-      
-    end    
   end
-  
-  context "Any valid schedule" do
+
+
+  context "extra available resources" 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"]
-      )
+      @s = Schedule.new(
+        :teams => %w(a1 a2 a3 a4 a5),
+        :rules => [
+          Rule.new(
+            :wday => 3,
+            :gt => ["7:00PM", "9:00PM"],
+            :ps => %w(one two three four)
+          )
+        ]
+      ).generate
     end
 
-    should "have gamedays that respect the wdays attribute" do
-      @s.wdays = [3,5]
-      @s.generate
-    
+    should "have a maximum of (teams/2) games per day" do
       @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      
-    
-    context "with the option optimize set to true" do
-      should "have at most (playing_surfaces*game_times) games per gameday" do
-        @s.generate                    
-        assert @s.gamedays.first.games.size == (@s.playing_surfaces.size * @s.game_times.size)
+        assert gd.games.size <= @s.teams.size/2
       end
     end
-    
-    context "with the option optimize set to false" do
-      setup do
-        @s.optimize = false
-      end
-      
-      should "never have more than (number of teams / 2) games per gameday" do
-        @s.teams = %w(only four teams here)
-        @s.generate          
-        assert @s.gamedays.first.games.size == @s.teams.size / 2
+
+    should "not have a team that play more than once on a single day" do
+      @s.gamedays.each do |gd|
+        day_teams = gd.games.collect{|g| [g.team_a,g.team_b]}.flatten
+        unique_day_teams = day_teams.uniq
+        assert_equal day_teams.size, unique_day_teams.size
       end
     end
-    
-    context "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 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
+
+
+  context "multi flights" do
+    setup do
+      @s = Schedule.new(
+        :teams => [
+          %w(A1 A2 A3 A4 A5 A6 A7 A8),
+          %w(B1 B2 B3 B4 B5 B6 B7 B8),
+          %w(C1 C2 C3 C4 C5 C6 C7 C8),
+          %w(D1 D2 D3 D4 D5 D6 D7 D8)
+        ],
+
+        :rules => [
+          Rule.new(
+            :wday => 3,
+            :gt => ["7:00PM", "9:00PM"],
+            :ps => ["one","two"]
+          )
+        ],
+
+        :start_date => Date.parse("2011/01/26"),
+        :exclude_dates => [
+          Date.parse("2011/02/02")
+        ]
+      ).generate
+    end
+
+    should "generate separate round-robins" do
+      assert_equal 4, @s.flights.size
+      4.times { |i| assert @s.round_robin?(i)}
+    end
+
+    should "have a correct total number of games" do
+      assert_equal 112, @s.gamedays.collect{|gd| gd.games.size}.inject{|x,sum| x+sum}
+    end
+
+    should "not have games for a date that is excluded" do
+      assert !@s.gamedays.collect{|gd| gd.date}.include?(Date.parse("2011/02/02"))
+      assert @s.gamedays.collect{|gd| gd.date}.include?(Date.parse("2011/02/09"))
     end
-    
-    context "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
+
+  ##### RULES #######
+  should "auto create array for gt and ps" do
+    @s = Schedule.new(
+      :teams => %w(a1 a2 a4 a5),
+      :rules => [
+        Rule.new(:wday => 1, :gt => "7:00PM", :ps => "The Field")
+      ]
+    ).generate
+
+    assert_equal [DateTime.parse("7:00PM")], @s.rules.first.gt
+    assert_equal ["The Field"], @s.rules.first.ps
+  end
+
+  context "no rules specified" do
+    setup {@s = Schedule.new(:teams => %w(a1 a2 a4 a5))}
+    should "raise an exception" do
+      exception = assert_raise(RuntimeError){@s.generate}
+      assert_equal "You need to specify at least 1 rule", exception.message
+    end
+  end
+
+  context "multiple rules on the same weekday" do
+    setup do
+      @s = Schedule.new
+      @s.teams = [%w(a1 a2 a3 a4 a5), %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))
+      ]
+      @s.start_date = Date.parse("2011/01/27")
+      @s.generate
+    end
+
+    should "keep games on the same day" do
+      cur_date = @s.start_date
+      @s.gamedays.each_with_index do |gd,i|
+        assert_equal cur_date, gd.date
+
+        #check all days to make sure that our rules are respected. We don't check
+        #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
+          cur_date += 7
+        end
       end
-      
-      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
+
+  def some_rules
+    [
+      Rule.new(:wday => 1, :gt => "7:00PM", :ps => "one"),
+      Rule.new(:wday => 1, :gt => "8:00PM", :ps => %w(one two))
+    ]
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rrschedule
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 8
-  version: 0.1.8
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - flamontagne
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-18 00:00:00 -05:00
+date: 2011-01-25 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,14 +40,15 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
+- README.markdown
 files: 
 - .document
 - .gitignore
 - LICENSE
-- README.rdoc
+- README.markdown
 - Rakefile
 - VERSION
+- branches_info.markdown
 - lib/rrschedule.rb
 - test/helper.rb
 - test/test_rrschedule.rb

data/README.rdoc

@@ -1,125 +0,0 @@
-= rrschedule
-
-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.
-Each round of the round-robin is splitted into multiple gamedays that respect these constraints. 
-
-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. So rrschedule will put the remaining games of this round on the next gameday 
-and will start a new round right after.
-
-
-== Demo
-Online round-robin generator using RRSchedule: http://rrschedule.azanka.ca
-
-== Installation
-  gem install rrschedule
-  require 'rrschedule'
-
-== Prepare the schedule
-  teams = ["Rockets","Jetpacks","Snakes","Cobras","Wolves","Huskies","Tigers","Lions",
-           "Moose","Sprinklers","Pacers","Cyclops","Munchkins","Magicians","French Fries"]
-           
-  schedule=RRSchedule::Schedule.new(
-                                  #array of teams that will compete against each other in the season
-                                  :teams => teams,  
-                                  
-                                  #list of available playing surfaces (volleyball fields, curling sheets, tennis courts, etc)
-                                  :playing_surfaces => ["A","B","C","D"],
-                                  
-                                  #day(s) of the week where games are played
-                                  :wdays => [3],
-                                  
-                                  #Season will start on...                
-                                  :start_date => Date.parse("2010/10/13"),
-                                  
-                                  #array of dates WITHOUT games
-                                  :exclude_dates => [
-                                                      Date.parse("2010/11/24"),
-                                                      Date.parse("2010/12/15"),
-                                                      Date.parse("2010/12/22"),
-                                                      Date.parse("2010/12/29")
-                                                    ],
-                                                    
-                                  #1 for Round Robin, 2 for Double Round Robin and so on. Default is 1
-                                  :cycles => 1,
-                                  
-                                  #Shuffle team order before each cycle. Default is true
-                                  :shuffle_initial_order => true,
-                                  
-                                  #Times of the day where the games are played
-                                  :game_times => ["10:00 AM", "1:00 PM"]
-                                )
-
-== Generate the schedule
-  schedule.generate
-  
-== Playing with the output
-
-=== human readable schedule
-  puts schedule.to_s
-
-=== Iterate through schedule
-  schedule.gamedays.each do |gd|
-    puts gd.date.strftime("%Y/%m/%d")
-    puts "===================="
-    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.strftime("%I:%M %p")}"     
-    end
-    puts "\n"
-  end
-
-=== Team schedule
-  test_team = "Sprinklers"
-  games=schedule.by_team(test_team)
-  puts "Schedule for team ##{test_team.to_s}"
-  games.each do |g|
-    puts "#{g.game_date.strftime("%Y-%m-%d")}: against #{g.team_a == test_team ? g.team_b.to_s : g.team_a.to_s} on playing surface ##{g.playing_surface} at #{g.game_time.strftime("%I:%M %p")}"     
-  end
-
-=== Face to Face
-  games=schedule.face_to_face("Lions","Moose")
-  puts "FACE TO FACE: Lions Vs Moose"
-  games.each do |g|
-    puts g.game_date.strftime("%Y/%m/%d") + " on playing surface " + g.playing_surface.to_s + " at " + g.game_time.strftime("%I:%M %p")
-  end
-
-=== Each round of the roun-robin without any date/time or playing location info
-  #If you have an ODD number of teams you will see a "dummy" opponent in each round
-  schedule.rounds.each do |round|
-    puts "Round ##{round.round}"
-    round.games.each do |g|
-      puts g.team_a.to_s + " Vs " + g.team_b.to_s
-    end
-    puts "\n"
-  end
-  
-== Issues / Other
-
-Starting from version 0.1.5, calling Schedule#gamedays will returns an array of Gameday instances.
-If you upgrade to this version you will need to change your code accordingly.
-
-  #this won't work anymore
-  schedule.gamedays.each do |gd,games|
-      puts gd
-      
-      games.each do |g|
-      end
-      #...
-  end
-  
-  #do this instead
-  schedule.gamedays.each do |gd|
-    puts gd.date
-    gd.games.each do |g|
-    end
-    #...
-  end
-
-
-Hope this gem will be useful to some people!
-
-You can read my blog here: www.rubyfleebie.com