rrschedule 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 flamontagne
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,100 @@
+= rrschedule
+
+RRSchedule make it easier to generate Round-Robin sport seasons. 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 groups 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 (only 6 games can be played). RRSchedule will put the rest of the games
+for this round on the next gameday and will start a new round right after.
+
+
+== Installation
+  gem install rrschedule (not on gemcutter yet... hold on)
+  require 'rrschedule.rb'
+
+== 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"]
+           
+  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 => Time.zone.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")
+                                                    ],
+                                                    
+                                  #1 for Round Robin, 2 for Double Round Robin and so on
+                                  :cycles => 1,
+                                  
+                                  #Shuffle team order before each cycle
+                                  :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
+
+=== Round by round... without the schedule 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
+
+=== 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}"     
+  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
+  end
+
+=== Iterate the schedule
+  schedule.gamedays.each do |gd,games|
+    puts gd
+    puts "===================="
+    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"
+  end
+
+== Copyright
+
+Copyright (c) 2010 flamontagne. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rrschedule"
+    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.authors = ["flamontagne"]
+    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
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rrschedule #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/example.rb

@@ -0,0 +1,56 @@
+require 'rrschedule.rb'
+Time.zone = "America/New_York"
+
+teams = ["Rockets","Jetpacks","Snakes","Cobras","Wolves","Huskies","Tigers","Lions","Moose","Sprinklers","Pacers","Cyclops","Munchkins","Magicians","French Fries"]
+schedule=RRSchedule::Schedule.new(
+                                :teams => teams,  #array of teams that will compete against each other in the season (can be any kind of object)
+                                :playing_surfaces => ["A","B","C","D"], #list of available playing surfaces (volleyball fields, curling sheets, tennis courts, etc)
+                                :wdays => [3], #day(s) of the week where games are played
+                                :start_date => Time.zone.parse("2010/10/13"), #Season will start on...                
+                                :exclude_dates => [ #array of dates WITHOUT games
+                                                    Time.zone.parse("2010/11/24"),
+                                                    Time.zone.parse("2010/12/15"),
+                                                    Time.zone.parse("2010/12/22"),
+                                                    Time.zone.parse("2010/12/29")
+                                                  ],
+                                :cycles => 1, #1 for Round Robin, 2 for Double Round Robin and so on
+                                :shuffle_initial_order => true, #Shuffle team order before each cycle
+                                :game_times => ["10:00 AM", "1:00 PM"] #Times of the day where the games are played
+                              )
+res=schedule.generate
+
+#human readable schedule
+puts schedule.to_s
+
+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
+
+#display a 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}"     
+#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
+#end
+
+#How to iterate the schedule
+#schedule.gamedays.each do |gd,games|
+#  puts gd
+#  puts "===================="
+#  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"
+#end

data/lib/rrschedule.rb

@@ -0,0 +1,176 @@
+# rrschedule (Round Robin Schedule generator)
+# Auhtor: François Lamontagne
+############################################################################################################################
+require 'rubygems'
+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
+
+    def initialize(params={})
+      store_params(params)
+    end
+    
+        
+    def generate(params={})
+      @teams = @teams.sort_by{rand} if self.shuffle_initial_order
+      initial_order = @teams.clone
+      current_cycle = 0
+      current_round = 0
+      all_games = []      
+
+      #Loop start here
+      begin
+        games = []
+        t = @teams.clone
+        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}
+        end
+        #round completed
+        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])})
+        
+        games.reject! {|g| g[:team_a] == :dummy || g[:team_b] == :dummy}
+        all_games.reject! {|g| g[:team_a] == :dummy || g[:team_b] == :dummy}
+          
+        @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
+          end
+        end
+      end until @teams == initial_order && current_cycle==self.cycles
+      @teams.delete(:dummy)
+      slice(all_games)      
+    end
+
+
+    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)}
+      end
+      res.flatten
+    end
+    
+    def to_s
+      res = ""
+      res << "#{@schedule.keys.size.to_s} gamedays\n"    
+      @schedule.sort.each do |gd,games|
+        gd_proc = lambda {gd.strftime("%Y-%m-%d")}
+        res << gd_proc.call + "\n"
+        res << "=" * gd_proc.call.length + "\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"
+        end
+        res << "\n"
+      end
+      res
+    end
+    
+    def gamedays
+      @schedule.sort
+    end        
+    
+    def by_team(team)
+      gms=[]
+      self.gamedays.each do |gd,games|
+        #games = games.each {|g| g.game_date = gd}
+        gms << games.select{|g| g.team_a == team || g.team_b == team}
+      end
+      gms.flatten
+    end
+
+    private  
+
+    def teams=(arr)
+      @teams = arr.clone
+      @teams << :dummy if arr.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
+            
+      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?        
+
+        cur_wday = wdays_stack.shift        
+        cur_date = next_game_date(cur_date,cur_wday)
+        cur_gt = gt_stack.shift
+        
+        res[cur_date] = []
+        slice.each_with_index do |g,game_index|          
+          cur_ps = ps_stack.shift
+          res[cur_date] << 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
+        cur_date += 1.day
+      end
+      @schedule = res        
+    end
+    
+    def next_game_date(dt,wday)
+      dt += 1.days until wday == dt.wday && !self.exclude_dates.include?(dt)
+      dt
+    end
+    
+    def games_per_day
+      self.playing_surfaces.size * self.game_times.size
+    end
+
+    def store_params(params)
+      self.teams = params[:teams] if params[:teams].respond_to?(:to_ary)
+      self.playing_surfaces = params[:playing_surfaces] if params[:playing_surfaces].respond_to?(:to_ary)      
+      self.cycles = params[:cycles] if params[:cycles].respond_to?(:to_int)
+      self.game_times = params[:game_times] if params[:game_times].respond_to?(:to_ary)
+      self.shuffle_initial_order = 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]) if params[:wdays].respond_to?(:to_ary) || params[:wdays].respond_to?(:to_int)      
+    end
+    
+    
+  end  
+  
+  class Game
+    attr_accessor :team_a, :team_b, :playing_surface, :game_time, :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_date = params[:game_date]
+    end
+  end
+  
+  class Round
+    attr_accessor :round, :games
+    
+    def initialize(params={})
+      self.round = params[:round]
+      self.games = params[:games]
+    end
+  end
+end
+

data/rrschedule.gemspec

@@ -0,0 +1,55 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rrschedule}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["flamontagne"]
+  s.date = %q{2010-11-07}
+  s.description = %q{This gem automate the process of creating a round-robin sport schedule.}
+  s.email = %q{flamontagne@azanka.ca}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/example.rb",
+     "lib/rrschedule.rb",
+     "rrschedule.gemspec",
+     "test/helper.rb",
+     "test/test_rrschedule.rb"
+  ]
+  s.homepage = %q{http://github.com/flamontagne/rrschedule}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Round-Robin schedule generator}
+  s.test_files = [
+    "test/test_rrschedule.rb",
+     "test/helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rrschedule'
+
+class Test::Unit::TestCase
+end

data/test/test_rrschedule.rb

@@ -0,0 +1,7 @@
+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"
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: rrschedule
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- flamontagne
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-07 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: This gem automate the process of creating a round-robin sport schedule.
+email: flamontagne@azanka.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/example.rb
+- lib/rrschedule.rb
+- rrschedule.gemspec
+- test/helper.rb
+- test/test_rrschedule.rb
+has_rdoc: true
+homepage: http://github.com/flamontagne/rrschedule
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Round-Robin schedule generator
+test_files: 
+- test/test_rrschedule.rb
+- test/helper.rb