rrschedule 0.1.6 → 0.1.7

data/README.rdoc

@@ -12,12 +12,14 @@ impossible to complete one round in a single day. So rrschedule will put the rem
 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
-  Time.zone = "America/New_York"
   teams = ["Rockets","Jetpacks","Snakes","Cobras","Wolves","Huskies","Tigers","Lions",
            "Moose","Sprinklers","Pacers","Cyclops","Munchkins","Magicians","French Fries"]
            
@@ -32,14 +34,14 @@ and will start a new round right after.
                                   :wdays => [3],
                                   
                                   #Season will start on...                
-                                  :start_date => Time.zone.parse("2010/10/13"),
+                                  :start_date => Date.parse("2010/10/13"),
                                   
                                   #array of dates WITHOUT games
                                   :exclude_dates => [
-                                                      Time.zone.parse("2010/11/24"),
-                                                      Time.zone.parse("2010/12/15"),
-                                                      Time.zone.parse("2010/12/22"),
-                                                      Time.zone.parse("2010/12/29")
+                                                      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
@@ -62,10 +64,10 @@ and will start a new round right after.
 
 === Iterate through schedule
   schedule.gamedays.each do |gd|
-    puts gd.date
+    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}"     
+      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
@@ -75,14 +77,14 @@ and will start a new round right after.
   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}"     
+    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.to_s + " on playing surface " + g.playing_surface.to_s + " at " + g.game_time.to_s
+    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

data/Rakefile

@@ -8,11 +8,10 @@ begin
     gem.summary = %Q{Round-Robin schedule generator}
     gem.description = %Q{This gem automate the process of creating a round-robin sport schedule.}
     gem.email = "flamontagne@azanka.ca"
-    gem.homepage = "http://github.com/flamontagne/rrschedule"
+    gem.homepage = "http://flamontagne.github.com/rrschedule"
     gem.authors = ["flamontagne"]
-    gem.add_dependency 'activesupport'
+    #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
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.1.7

data/lib/rrschedule.rb

@@ -1,56 +1,114 @@
 # rrschedule (Round Robin Schedule generator)
 # Auhtor: François Lamontagne
 ############################################################################################################################
-require 'active_support/all'
 module RRSchedule
   class Schedule
-    attr_accessor :playing_surfaces, :game_times, :cycles, :wdays, :start_date, :exclude_dates, :shuffle_initial_order
-    attr_reader :teams, :rounds, :gamedays
+    attr_reader :playing_surfaces, :game_times, :cycles, :wdays, :start_date, :exclude_dates, 
+                :shuffle_initial_order, :optimize, :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|
+    
+    #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
-      
-      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])
-      
-      raise "each value in wdays must be between 0 and 6" if self.wdays.reject{|w| (0..6).member?(w)}.size > 0
+      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
+    
+    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
     end
     
+    
+    #This will generate the schedule based on the various parameters
     #TODO: consider refactoring with a recursive algorithm
     def generate(params={})
+      @gamedays = []
+      @rounds = []
       @teams = @teams.sort_by{rand} if self.shuffle_initial_order
       initial_order = @teams.clone
       current_cycle = current_round = 0
       all_games = []      
             
-      #Loop start here
+      #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!
-          games << {:team_a => team_a, :team_b => team_b}
-          all_games << {:team_a => team_a, :team_b => team_b}
+                    
+          matchup = {:team_a => team_a, :team_b => team_b}
+          games << matchup; all_games << matchup
         end
                 
-        current_round += 1 #round completed
+        current_round += 1
         
         @rounds ||= []
         @rounds << Round.new( 
@@ -127,17 +185,9 @@ module RRSchedule
       end
       return true
     end
-    
-    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
-      raise "teams have to be unique" if @teams.uniq.size < @teams.size  
-      @teams << :dummy if @teams.size.odd?
-    end
         
     private      
-    #Slice games according to playing surfaces and game times
+    #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     
@@ -169,17 +219,23 @@ module RRSchedule
         
         gameday.games = gameday.games.sort_by {|g| [g.game_time,g.playing_surface]}
         self.gamedays << gameday
-        cur_date += 1.day
+        cur_date += (60*60*24) 
       end
     end
     
+    #get the next gameday
     def next_game_date(dt,wday)
-      dt += 1.days until wday == dt.wday && !self.exclude_dates.include?(dt)
+      dt += (60*60*24) until wday == dt.wday && !self.exclude_dates.include?(dt)
       dt
     end
     
+    #how many games can we play per day? 
     def games_per_day
-      self.playing_surfaces.size * self.game_times.size
+      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
+      end
     end
   end  
 

data/test/test_rrschedule.rb

@@ -9,26 +9,21 @@ class TestRrschedule < Test::Unit::TestCase
       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.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)
-      )
-      
+      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)
-      )
-      
+      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
@@ -96,54 +91,73 @@ class TestRrschedule < Test::Unit::TestCase
         :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(
-        :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  
+    end      
     
-    should "be a valid round-robin" do
-      assert @s.round_robin?
+    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)
+      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
+    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
+      end
     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?
+    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
     
-    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 "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 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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rrschedule
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 0
   - 1
-  - 6
-  version: 0.1.6
+  - 7
+  version: 0.1.7
 platform: ruby
 authors: 
 - flamontagne
@@ -15,27 +15,13 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-11 00:00:00 -05:00
+date: 2010-11-18 00:00:00 -05:00
 default_executable: 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: thoughtbot-shoulda
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -45,7 +31,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id002
+  version_requirements: *id001
 description: This gem automate the process of creating a round-robin sport schedule.
 email: flamontagne@azanka.ca
 executables: []
@@ -66,7 +52,7 @@ files:
 - test/helper.rb
 - test/test_rrschedule.rb
 has_rdoc: true
-homepage: http://github.com/flamontagne/rrschedule
+homepage: http://flamontagne.github.com/rrschedule
 licenses: []
 
 post_install_message: