tournament 4.0.2 → 4.2.0

data/History.txt

@@ -1,6 +1,14 @@
+== 4.2.0 / 2011-03-20
+* Add ability to run statistics for the possibility report in more than one
+  process.
+* Add link to possibility report on pool index page.
+* Pretty formatting for large numbers.
+
+== 4.1.0 / 2011-03-17
+* Bug fix change team name and some cosmetic changes
+
 == 4.0.2 / 2011-03-14
 * Add ability to change the name of a team after tourny has started.  
-  FIXME: after team name change, admin must manually save all entries
 
 == 4.0.0 / 2011-03-14
 * 2011 bracket.

data/README.rdoc

@@ -20,7 +20,6 @@ basketball tournament pool.
   the entries and updating the tournament results bracket.  Useful as an
   adjunct to the command line script.
 * FIXME: Complete the test suite for the library and command line tool
-* FIXME: Can't change name of team after entries have been added
 
 == COMMAND LINE SYNOPSIS:
 
@@ -157,6 +156,16 @@ to control how the application is installed:
   modrails and Apache.  Example:
 
     --relative-root=/my_pool  (Default: empty, no root is set)
+
+* Number of statistics processors.  If you generate statistics for
+  the possibilities report, set this to the number of CPUs/cores your
+  machine has to get maximum performance.  If you set this to 1 or
+  to fewer than the number of CPUs/cores, you won't max CPU consumption
+  when calculating the possibility stats.  This might be considered
+  a 'good thing'.  Set this to 1 if your hosting provider charges you
+  for high CPU use.
+
+    --stats-processors=1   (Default: 2)
  
 * Administrator email address.  The web GUI will send emails
   when users register for creating entries in a pool. The following

data/Rakefile

@@ -27,7 +27,7 @@ Bones {
 
 #spec.opts << '--color'
 
-  exclude %w(tmp$ bak$ ~$ CVS \.svn \.git swp$ ^pkg ^doc bin/fake bin/gui_v2.rb ^tags$ ^webgui/log/.*\.log)
+  exclude %w(tmp$ bak$ ~$ CVS \.svn \.git swp$ ^pkg ^doc bin/fake bin/gui_v2.rb ^tags$ ^webgui/db/.*\.sqlite3 ^webgui/db/stats_.*\.yml ^webgui/log/.*\.log)
 
   rdoc.opts ["--line-numbers", "--force-update", "-W", "http://tournament.rubyforge.org/svn/trunk/%s"]
   rdoc.exclude [

data/bin/pool

@@ -55,6 +55,13 @@ Main do
       arity 1
       description "Relative URL root if you are installing the web application as a subdirectory in an existing website."
     end
+    option('stats-processors', 's') do
+      optional
+      argument :required
+      arity 1
+      cast :int
+      description "Number of processors to spawn when calculating the possibility statistics.  Set this to the number of CPUs/cores on your box."
+    end
     option('admin-email') do
       required
       argument :required

data/lib/tournament.rb

@@ -7,7 +7,7 @@ unless defined? Tournament
 module Tournament
 
   # :stopdoc:
-  VERSION = '4.0.2'
+  VERSION = '4.2.0'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/lib/tournament/bracket.rb

@@ -44,9 +44,9 @@ class Tournament::Bracket
   # For each possible outcome remaining in the pool, generates a bracket representing
   # that outcome and yields it to the caller's block.  This can take a very long time
   # with more than about 22 teams left.
-  def each_possible_bracket
+  def each_possible_bracket(batch = 0, num_batches = 1)
     puts "WARNING: This is likely going to take a very long time ... " if teams_left > 21
-    each_possibility do |possibility|
+    each_possibility(batch, num_batches) do |possibility|
       yield(bracket_for(possibility))
     end
   end
@@ -97,7 +97,7 @@ class Tournament::Bracket
   #
   # If no games have been played, we can represent each possibility
   # by every possible 7 bit binary number.
-  def each_possibility
+  def each_possibility(batch = 0, num_batches = 1)
     # bit masks of games that have been played
     # played_mask is for any game where a winner has been determined
     # first is a mask where the first of the matched teams won
@@ -151,9 +151,19 @@ class Tournament::Bracket
     #num_possibilities = 0
     #shifts.size.times { |n| num_possibilities |= (1 << n) }
 
-    #puts "Checking #{num_possibilities} (#{number_of_outcomes}) possible outcomes."
-    possibility = num_possibilities - 1
-    while possibility >= 0
+    # Handle a batch
+    limit = nil
+    offset = 0
+    if batch && num_batches && num_batches > 1
+      limit = num_possibilities / num_batches
+      offset = batch * limit
+    end
+
+    possibility = num_possibilities - 1 - offset
+    puts "Checking #{limit.inspect} of #{number_of_outcomes} possible outcomes, offset: #{offset}, starting at: #{possibility}"
+
+    count_this_run = 0
+    while possibility >= 0 && (limit.nil? || count_this_run < limit)
       #puts "    possibility: #{Tournament::Bracket.jbin(possibility, teams.size - 1)}"
       real_poss = 0
       shifts.each_with_index do |s, i|
@@ -164,6 +174,7 @@ class Tournament::Bracket
       #puts "    real_poss: #{Tournament::Bracket.jbin(real_poss, teams.size - 1)}"
       yield(real_poss)
       possibility -= 1
+      count_this_run += 1
     end
   end
 

data/lib/tournament/pool.rb

@@ -381,8 +381,8 @@ class Tournament::Pool
     picks = (1..num_picks).map {|n| Tournament::Bracket.random_bracket(b.teams)}
     # Play out the bracket
     32.times { |n| b.set_winner(1,n+1, b.matchup(1, n+1)[rand(2)])}
-    10.times { |n| b.set_winner(2,n+1, b.matchup(2, n+1)[rand(2)])}
-#    8.times { |n| b.set_winner(3,n+1, b.matchup(3, n+1)[rand(2)])}
+    16.times { |n| b.set_winner(2,n+1, b.matchup(2, n+1)[rand(2)])}
+    2.times { |n| b.set_winner(3,n+1, b.matchup(3, n+1)[rand(2)])}
 #4.times { |n| b.set_winner(4,n+1, b.matchup(4, n+1)[rand(2)])}
     #2.times { |n| b.set_winner(5,n+1, b.matchup(5, n+1)[rand(2)])}
     #1.times { |n| b.set_winner(6,n+1, b.matchup(6, n+1)[rand(2)])}
@@ -687,56 +687,91 @@ class Tournament::Pool
   # Runs through every possible outcome of the tournament and
   # calculates each entry's chance to win as a percentage of the
   # possible outcomes the entry would win if the tournment came
-  # out that way.  If a block is provided, periodically reports
-  # progress by calling the block and passing it the percent complete
-  # and time remaining in seconds as arguments.
-  # Returns array of structs responding to times_champ, max_score,
-  # min_rank, entry and champs methods.  The entry method returns the
-  # Tournament::Entry object and the champs method returns a hash
+  # out that way.  Returns an array of Tournament::Possibility objects for
+  # each entry in the pool. These objects respond to :times_champ, :max_score,
+  # :min_rank, :entry and :champs methods.  The :entry method returns the
+  # Tournament::Entry object and the :champs method returns a hash
   # keyed on team name and whose values are the number of times that
   # team could win that would make the entry come in on top.
-  def possibility_stats
-    stats = @entries.map do |e|
+  # Options avaliable:
+  #   :processes => Number of Threads (default: 1) - Set this to the
+  #       number of CPU's on your computer to really peg CPU usage ;)
+  # This method spins up N processes to perform the work and will periodically
+  # report progress if passed a block responding to three parameters:
+  # 1) percentage of possibilities checked, 2) estimated time remaining in seconds
+  # and 3) total possibilities checked so far.
+  def possibility_stats(options = {})
+    options = options || {}
+    global_stats = @entries.map do |e|
       Tournament::Possibility.new(e)
     end
-    max_possible_score = @entries.map{|p| 0}
-    min_ranking = @entries.map{|p| @entries.size + 1}
-    times_winner = @entries.map{|p| 0 }
-    player_champions = @entries.map{|p| Hash.new {|h,k| h[k] = 0} }
+
+    # Create a collector to hold the results
+    collector = StatsCollector.new
+
+    # How many workers?
+    num_threads = options[:threads] || 1
+
+    threads = if num_threads == 1
+      # With just one worker, do it in-process
+      [possibility_stats_thread(collector, 0, 1)]
+    else
+      # With more than one worker, create a drb
+      # server and multiple clients
+      possibility_stats_cluster(collector, num_threads)
+    end
+
+    puts "CREATED WORKERS: #{threads}"
+
+    # Wait for them to finish
     count = 0
-    old_percentage = -1 
-    old_remaining = 1_000_000_000_000
     start = Time.now.to_f
-    self.tournament_entry.picks.each_possible_bracket do |poss|
-      poss_scores = @entries.map{|p| p.picks.score_against(poss, self.scoring_strategy)}
-      sort_scores = poss_scores.sort.reverse
-      @entries.each_with_index do |entry, i|
-        score = poss_scores[i]
-        stat = stats[i]
-        stat.max_score = score if score > stat.max_score
-        rank = sort_scores.index(score) + 1
-        stat.min_rank = rank if rank < stat.min_rank
-        stat.times_champ += 1 if rank == 1
-        if rank == 1
-          stat.champs[poss.champion.name] ||= 0
-          stat.champs[poss.champion.name] += 1
-        end
-      end
-      count += 1
-      percentage = (count * 100.0 / self.tournament_entry.picks.number_of_outcomes)
+    old_remaining = 1_000_000_000_000_000
+    old_percentage = 0
+    last_thousand = 1000
+    total_outcomes = self.tournament_entry.picks.number_of_outcomes
+    while count < total_outcomes
+      sleep 1
+      count = collector.total_count
+      next if count == 0
+      percentage = (count * 100.0 / total_outcomes)
       elapsed = Time.now.to_f - start
       spp = elapsed / count
       remaining = ((self.tournament_entry.picks.number_of_outcomes - count) * spp).to_i
-      if (percentage.to_i != old_percentage) || (remaining < old_remaining)
+      if (percentage.to_i != old_percentage) || (remaining < old_remaining) || count > last_thousand
         old_remaining = remaining
         old_percentage = percentage.to_i
         if block_given?
-          yield(percentage.to_i, remaining)
+          yield(percentage.to_i, remaining, count)
         end
       end
+      if count > last_thousand
+        last_thousand = (count / 1000 + 1) * 1000
+      end
+    end
+
+    # join
+    puts
+    puts "Waiting for threads to finish"
+    threads.each {|t| t.join}
+    
+    if @drb_server
+      puts "Waiting for drb services to stop"
+      DRb.stop_service
+      if DRb.thread
+        DRb.thread.stop
+        DRb.thread.join
+      end
+    end
+   
+    # Collect all the stats 
+    num_threads.times do |n|
+      global_stats.each_with_index do |stats, idx|
+        stats.merge!(collector.stats_of(n)[idx])
+      end
     end
-    stats.sort!
-    return stats
+    global_stats.sort!
+    return global_stats
   end
 
   # Runs through every possible outcome of the tournament and calculates
@@ -750,9 +785,9 @@ class Tournament::Pool
       return
     end
     out << "Checking #{self.tournament_entry.picks.number_of_outcomes} possible outcomes" << "\n"
-    stats = possibility_stats do |percentage, remaining|
+    stats = possibility_stats(:threads => 2) do |percentage, remaining, num_processed|
       hashes = '#' * (percentage.to_i/5) + '>'
-      out << "\rCalculating: %3d%% +#{hashes.ljust(20, '-')}+ %5d seconds remaining" % [percentage.to_i, remaining]
+      out << "\rCalculating: %3d%% +#{hashes.ljust(20, '-')}+ %5d seconds remaining, %d" % [percentage.to_i, remaining, num_processed]
     end
     out << "\n"
     #puts "SORT: #{stats.inspect}"
@@ -781,4 +816,114 @@ class Tournament::Pool
     end
     nil
   end
+
+  require 'drb/drb'
+  URI = "druby://localhost:38787"
+  class StatsCollector
+    include DRb::DRbUndumped
+    def initialize
+      @counts = {}
+      @stats = {}
+    end
+    def count(child, count)
+      @counts[child] = count
+    end
+    def stats(child, stat)
+      @stats[child] = stat
+    end
+    def stats_of(child)
+      @stats[child]
+    end
+    def count_of(child)
+      @count[child]
+    end
+    def total_count
+      @counts.values.inject(0) {|sum, count| sum += count}
+    end
+  end
+
+  # Make a subprocess look like a thread
+  class StatsProcess
+    def initialize(pid)
+      @pid = pid
+    end
+    def join
+      Process.waitpid @pid
+    end
+  end
+
+  protected
+
+  # Starts a drb server that spins off #total_threads child processes
+  # that each do a chunk of the calculation.  Returns array
+  # of StatsProcess objects that can be joined
+  def possibility_stats_cluster(collector, total_threads)
+    # Create a drb server
+    @drb_server = DRb.start_service(URI, collector)
+    threads = []
+    total_threads.times do |n|
+      pid = fork
+      if pid
+        # Track the child process
+        threads << StatsProcess.new(pid)
+      else
+        # child
+        DRb.start_service
+        remote_collector = DRbObject.new_with_uri(URI)
+        puts "Child #{n} got remote collector: #{remote_collector.inspect}"
+        # Start off collection thread
+        t = possibility_stats_thread(remote_collector, n, total_threads)
+        # Wait for it to finish 
+        t.join
+        exit 0
+      end
+    end
+    return threads
+  end
+
+  # Compute possibility stats for the given thread num and total threads.
+  # Tracks number of possibilities processed in collector and stores 
+  # an Array of Tournament::Possibility objects in the collector when
+  # finished
+  def possibility_stats_thread(collector, thread_num, total_threads)
+    puts "Creating stats thread #{thread_num} of #{total_threads}"
+    t = Thread.new do
+      count = 0
+      collector.count(thread_num, count)
+      stats = @entries.map do |e|
+        Tournament::Possibility.new(e)
+      end
+      self.tournament_entry.picks.each_possible_bracket(thread_num, total_threads) do |poss|
+        poss_scores = @entries.map{|p| p.picks.score_against(poss, self.scoring_strategy)}
+        # precalculate ranks
+        sorted = poss_scores.sort_by{|s| -s}
+        sort_scores = sorted.inject({}) do |h, s|
+          h[s] = sorted.index(s) + 1
+          h
+        end
+        @entries.each_with_index do |entry, i|
+          score = poss_scores[i]
+          stat = stats[i]
+          stat.max_score = score if score > stat.max_score
+          rank = sort_scores[score]
+          stat.min_rank = rank if rank < stat.min_rank
+          stat.times_champ += 1 if rank == 1
+          if rank == 1
+            stat.champs[poss.champion.name] ||= 0
+            stat.champs[poss.champion.name] += 1
+          end
+        end
+        count += 1
+        if count % 1000 == 0
+          collector.count(thread_num, count)
+        end
+      end
+      # Final count and stats
+      collector.count(thread_num, count)
+      collector.stats(thread_num, stats)
+    end
+    t.abort_on_exception = true
+    t
+  end
+
 end

data/lib/tournament/possibility.rb

@@ -16,4 +16,18 @@ class Tournament::Possibility
       (self.min_rank <=> other.min_rank).nonzero? ||
       other.max_score <=> self.max_score
   end
+  # Combine self with another possibility
+  def merge!(other)
+    @times_champ += other.times_champ
+    @max_score = [@max_score, other.max_score].max
+    @min_rank = [@min_rank, other.min_rank].min
+
+    # Merge champs
+    @champs.keys.each do |name|
+      @champs[name] += (other.champs[name] || 0)
+    end
+    (other.champs.keys - @champs.keys).each do |name|
+      @champs[name] = other.champs[name]
+    end
+  end
 end

data/lib/tournament/webgui_installer.rb

@@ -52,7 +52,8 @@ class Tournament::WebguiInstaller
       ['admin-email', 'ADMIN_EMAIL'],
       ['relative-root', 'RELATIVE_URL_ROOT'],
       ['smtp-configuration', 'SMTP_CONFIGURATION'],
-      ['prince-path', 'PRINCE_PATH']
+      ['prince-path', 'PRINCE_PATH'],
+      ['stats-processors', 'STATS_PROCESSORS']
     ].each do |config_name, constant_name|
       if config_options[config_name]
         puts "  -> Setting config option #{config_name} to #{config_options[config_name]}"

data/test/test_webgui_installer.rb

@@ -48,13 +48,15 @@ class WebguiInstallerTest < Test::Unit::TestCase
       {
         'prince-path' => 'foo',
         'admin-email' => 'admin@admin.com',
-        'site-name' => 'My Site'
+        'site-name' => 'My Site',
+        'stats-processors' => 5
       }
     )
     new_config = File.read(File.join(@installer.install_dir, 'config', 'initializers', 'pool.rb'))
     assert_match(/PRINCE_PATH = "foo"/, new_config)
     assert_match(/TOURNAMENT_TITLE = "My Site"/, new_config)
     assert_match(/ADMIN_EMAIL = "admin@admin.com"/, new_config)
+    assert_match(/STATS_PROCESSORS = 5/, new_config)
   end
 
   #def test_prince_install

data/webgui/app/controllers/teams_controller.rb

@@ -66,7 +66,7 @@ class TeamsController < ApplicationController
           if @pool.teams_set?
             @pool.pool.tournament_entry.bracket.change_team_name(old_name, old_short_name, team.name, team.short_name)
             @pool.save!
-            @pool.user_entries.each do |entry|
+            @pool.entries.each do |entry|
               entry.bracket.change_team_name(old_name, old_short_name, team.name, team.short_name)
               entry.save!
             end

data/webgui/app/helpers/application_helper.rb

@@ -1,3 +1,10 @@
 # Methods added to this helper will be available to all templates in the application.
 module ApplicationHelper
+  def has_stats_file(pool_id)
+    @has_stats_file ||= begin
+      path = File.expand_path(File.join(RAILS_ROOT, 'db', ReportsController::STATS_DATAFILE_NAME % pool_id))
+      File.exist?(path) ? :true : :false
+    end
+    @has_stats_file == :true
+  end
 end

data/webgui/app/views/pool/index.html.erb

@@ -7,17 +7,20 @@
 <small>
 <% if current_user && pool.user_id == current_user.id %>
 <% if pool.tournament_entry -%>
-<%= link_to '[Tourny Bracket]', :controller => 'admin', :action => 'bracket', :id => pool.id %>
+<%= link_to '[Tourny Results]', :controller => 'admin', :action => 'bracket', :id => pool.id %>
 <% end -%>
 <%= link_to '[Recap]', :controller => 'admin', :action => 'recap', :id => pool.id%>
 <%= link_to '[Edit]', :controller => 'admin', :action => 'pool', :id => pool.id %>
 <%= link_to '[Entries]', :controller => 'admin', :action => 'entries', :id => pool.id %>
 <% else %>
 <% if pool.tournament_entry -%>
-<%= link_to '[Tourny Bracket]', :controller => 'entry', :action => 'show', :id => pool.tournament_entry.id %>
+<%= link_to '[Tourny Results]', :controller => 'entry', :action => 'show', :id => pool.tournament_entry.id %>
 <% end %>
 <% end %>
 <%= link_to '[Leader Board]', :controller => 'reports', :action => 'show', :id => pool.id, :report => 'leader' %>
+<% if has_stats_file(pool.id) -%>
+<%= link_to '[Possibilities]', :controller => 'reports', :action => 'show', :id => pool.id, :report => 'possibility' %>
+<% end -%>
 <%= link_to '[Reports]', :controller => 'reports', :action => 'show', :id => pool.id %>
 </small>
 <div class="poollistinfo">

data/webgui/app/views/reports/_possibility.html.erb

@@ -5,7 +5,7 @@
 <li>Total games played: <%= pool.tournament_entry.picks.games_played %></li>
 <li>Pool Tie Break: <%=pool.tournament_entry.tie_breaker || '-' %></li>
 <li>Number of entries: <%=pool.entries.size%></li>
-<li>Number of remaining outcomes: <%=pool.tournament_entry.picks.number_of_outcomes%></li>
+<li>Number of remaining outcomes: <%=number_with_delimiter(pool.tournament_entry.picks.number_of_outcomes)%></li>
 </ul>
 <% end %>
 <% if @message %>
@@ -38,7 +38,7 @@
 <a class="info" href="#">Detail
 <span class="flow">
 <% stat.champs.sort_by{|k,v| -v}.each do |team, occurrences| -%>
-<nobr><%=team%> <%=occurrences%> (<%="%5.2f" % (occurrences.to_f * 100.0 / stat.times_champ)%>%)</nobr>
+<nobr><%=team%> <%=number_with_delimiter(occurrences)%> (<%="%5.2f" % (occurrences.to_f * 100.0 / stat.times_champ)%>%)</nobr>
 <br/>
 <% end -%>
 </span>

data/webgui/config/environment.rb

@@ -27,7 +27,7 @@ Rails::Initializer.run do |config|
   # config.gem "hpricot", :version => '0.6', :source => "http://code.whytheluckystiff.net"
   # config.gem "sqlite3-ruby", :lib => "sqlite3"
   # config.gem "aws-s3", :lib => "aws/s3"
-  config.gem "tournament", :version => "~> 4.0.0"
+  config.gem "tournament", :version => ">= 4.0.0"
 
   # Only load the plugins named here, in the order given. By default, all plugins 
   # in vendor/plugins are loaded in alphabetical order.

data/webgui/config/initializers/pool.rb

@@ -34,3 +34,8 @@ end
 # Full path to the prince xml executable if you want printable
 # styled PDF's of tournament brackets.
 PRINCE_PATH = nil unless defined?(PRINCE_PATH)
+
+# Number of processes to use when calculating possibility
+# report.  Set this to the number of CPU's on the machine
+# you run the report on.
+STATS_PROCESSORS = 2

data/webgui/lib/tasks/possibility.rake

@@ -5,9 +5,9 @@ namespace :report do
     pool_id = args[:pool_id].to_i
     tournament_pool = Pool.find(pool_id).pool
     puts "Calculating stats for pool with #{tournament_pool.tournament_entry.picks.number_of_outcomes} possible outcomes ..."
-    stats = tournament_pool.possibility_stats do |percentage, remaining|
+    stats = tournament_pool.possibility_stats(:threads => STATS_PROCESSORS) do |percentage, remaining, num_processed|
       hashes = '#' * (percentage.to_i/5) + '>'
-      print "\rCalculating: %3d%% +#{hashes.ljust(20, '-')}+ %5d seconds remaining" % [percentage.to_i, remaining]
+      print "\rCalculating: %3d%% +#{hashes.ljust(20, '-')}+ %5d seconds remaining, processed %d" % [percentage.to_i, remaining, num_processed]
     end
     puts
     stats_yaml_file = File.join(RAILS_ROOT, 'db', "stats_#{pool_id}.yml")

data/webgui/public/stylesheets/main.css

@@ -58,7 +58,13 @@ h1 {
 }
 #main {
   float: left;
-  width: 70%;
+  width: 65%;
+  margin-left: 10px;
+}
+#main_report {
+  float: left;
+  width: 100%;
+  margin-left: 10px;
 }
 #main h2, #main h3, #main p {
   padding: 0 10px;

metadata

@@ -1,80 +1,79 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: tournament
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 4.2.0
   prerelease: 
-  version: 4.0.2
 platform: ruby
-authors: 
+authors:
 - Douglas A. Seifert
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-03-14 00:00:00 -07:00
+date: 2011-03-20 00:00:00.000000000 -07:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+dependencies:
+- !ruby/object:Gem::Dependency
   name: main
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &19735860 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *19735860
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &19735380 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.8.7
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rails
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *19735380
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &19734880 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
         version: 2.3.11
   type: :runtime
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: bones
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *19734880
+- !ruby/object:Gem::Dependency
+  name: bones
+  requirement: &19734400 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 3.6.5
   type: :development
-  version_requirements: *id004
-description: |-
-  Small library, command line program and Rails web GUI for managing a NCAA
-  basketball tournament pool.
+  prerelease: false
+  version_requirements: *19734400
+description: ! 'Small library, command line program and Rails web GUI for managing
+  a NCAA
+
+  basketball tournament pool.'
 email: doug@dseifert.net
-executables: 
+executables:
 - benchmark_pool
 - gui.rb
 - picker
 - pool
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - History.txt
 - README.rdoc
 - bin/benchmark_pool
 - bin/picker
 - bin/pool
-files: 
+files:
 - History.txt
 - README.rdoc
 - Rakefile
@@ -345,36 +344,35 @@ files:
 has_rdoc: true
 homepage: http://www.dseifert.net/code/tournament
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --line-numbers
 - --force-update
 - -W
 - http://tournament.rubyforge.org/svn/trunk/%s
 - --main
 - README.rdoc
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: tournament
-rubygems_version: 1.6.1
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Small library, command line program and Rails web GUI for managing a NCAA basketball tournament pool.
-test_files: 
+summary: Small library, command line program and Rails web GUI for managing a NCAA
+  basketball tournament pool.
+test_files:
 - test/test_webgui_installer.rb
 - test/test_tournament.rb