tournament 0.0.1

data/lib/tournament/pool.rb

@@ -0,0 +1,341 @@
+# Represents a NCAA tournament pool.  Contains 4 regions
+# of 16 teams each.  Champions of Region 1 and Region 2
+# and champions of Region 3 and Region 4 play each
+# other in the final four.
+class Tournament::Pool
+  attr_reader :regions  # The regions in the pool
+  attr_reader :entries  # Tournament::Entry objects for participants
+
+  # Create a new empty pool with no Regions or Entries
+  def initialize
+    @regions = Array.new(4)
+    @entries = []
+  end
+
+  # add regions to the pool.  Champ of region with index = 0 plays
+  # region with index = 1 and index == 2 plays index == 3.
+  def add_region(name, teams, index)
+    @regions[index] = {
+      :name => name,
+      :teams => teams
+    }
+  end
+
+  # Add an Tournament::Entry object to the pool
+  def add_entry(entry)
+    @entries << entry
+  end
+
+  # Add an Tournament::Entry object to the pool after reading the Tournament::Entry
+  # from the provided YAML file.
+  def add_entry_yaml(yaml)
+    @entries << YAML::load_file(yaml)
+  end
+
+  # Creates a bracket for the pool by combining all the
+  # regions into one bracket of 64 teams.  By default the
+  # bracket uses the basic scoring strategy.
+  def bracket
+    unless @bracket
+      if @regions.compact.size != 4
+        raise "Not all regions have been set."
+      end
+      all_teams = @regions.map do |region|
+        region[:teams]
+      end
+      all_teams = all_teams.flatten
+      @bracket = Tournament::Bracket.new(all_teams)
+    end
+    return @bracket
+  end
+
+  # Replaces the pool's bracket (as in after updating the bracket
+  # for game results)
+  def bracket=(new_bracket)
+    @bracket = new_bracket
+  end
+
+  # Creates a Pool object for the 2008 NCAA tournament
+  def self.ncaa_2008
+    pool = Tournament::Pool.new
+    pool.add_region("East",
+      [
+        Tournament::Team.new('North Carolina', 'UNC', 1),
+        Tournament::Team.new('Mt. St. Mary\'s', 'MSM', 16),
+        Tournament::Team.new('Indiana', 'Ind', 8),
+        Tournament::Team.new('Arkansas', 'Ark', 9),
+        Tournament::Team.new('Notre Dame', 'ND', 5),
+        Tournament::Team.new('George Mason', 'GM', 12),
+        Tournament::Team.new('Washington St.', 'WSt', 4),
+        Tournament::Team.new('Winthrop', 'Win', 13),
+        Tournament::Team.new('Oklahoma', 'Okl', 6),
+        Tournament::Team.new('St. Joseph\'s', 'StJ', 11),
+        Tournament::Team.new('Louisville', 'Lou', 3),
+        Tournament::Team.new('Boise St.', 'BSt', 14),
+        Tournament::Team.new('Butler', 'But', 7),
+        Tournament::Team.new('South Alabama', 'SAl', 10),
+        Tournament::Team.new('Tennessee', 'Ten', 2),
+        Tournament::Team.new('American', 'Am', 15)
+      ],
+      0
+    )
+    pool.add_region("Midwest",
+      [
+        Tournament::Team.new('Kansas', 'Kan', 1),
+        Tournament::Team.new('Portland St.', 'PSt', 16),
+        Tournament::Team.new('UNLV', 'ULV', 8),
+        Tournament::Team.new('Kent St.', 'KSt', 9),
+        Tournament::Team.new('Clemson', 'Clm', 5),
+        Tournament::Team.new('Villanova', 'Vil', 12),
+        Tournament::Team.new('Vanderbilt', 'Van', 4),
+        Tournament::Team.new('Siena', 'Sie', 13),
+        Tournament::Team.new('USC', 'USC', 6),
+        Tournament::Team.new('Kansas St.', 'KSU', 11),
+        Tournament::Team.new('Wisconsin', 'Wis', 3),
+        Tournament::Team.new('CSU Fullerton', 'CSF', 14),
+        Tournament::Team.new('Gonzaga', 'Gon', 7),
+        Tournament::Team.new('Davidson', 'Dav', 10),
+        Tournament::Team.new('Georgetown', 'GT', 2),
+        Tournament::Team.new('UMBC', 'UBC', 15)
+      ],
+      1
+    )
+    pool.add_region("South",
+      [
+        Tournament::Team.new('Memphis', 'Mem', 1),
+        Tournament::Team.new('TX Arlington', 'TxA', 16),
+        Tournament::Team.new('Mississippi St.', 'MiS', 8),
+        Tournament::Team.new('Oregon', 'Ore', 9),
+        Tournament::Team.new('Michigan St.', 'MSU', 5),
+        Tournament::Team.new('Temple', 'Tem', 12),
+        Tournament::Team.new('Pittsburgh', 'Pit', 4),
+        Tournament::Team.new('Oral Roberts', 'ORo', 13),
+        Tournament::Team.new('Marquette', 'Mar', 6),
+        Tournament::Team.new('Kentucky', 'Ken', 11),
+        Tournament::Team.new('Stanford', 'Sta', 3),
+        Tournament::Team.new('Cornell', 'Cor', 14),
+        Tournament::Team.new('Miami (FL)', 'Mia', 7),
+        Tournament::Team.new('St. Mary\'s', 'StM', 10),
+        Tournament::Team.new('Texas', 'Tex', 2),
+        Tournament::Team.new('Austin Peay', 'APe', 15)
+      ],
+      2
+    )
+    pool.add_region("West",
+      [
+        Tournament::Team.new('UCLA', 'ULA', 1),
+        Tournament::Team.new('Mis. Valley St', 'MVS', 16),
+        Tournament::Team.new('BYU', 'BYU', 8),
+        Tournament::Team.new('Texas A&M', 'A&M', 9),
+        Tournament::Team.new('Drake', 'Dra', 5),
+        Tournament::Team.new('W. Kentucky', 'WKy', 12),
+        Tournament::Team.new('Connecticut', 'Con', 4),
+        Tournament::Team.new('San Diego', 'SD', 13),
+        Tournament::Team.new('Purdue', 'Pur', 6),
+        Tournament::Team.new('Baylor', 'Bay', 11),
+        Tournament::Team.new('Xavier', 'Xav', 3),
+        Tournament::Team.new('Georgia', 'UG', 14),
+        Tournament::Team.new('West Virginia', 'WVa', 7),
+        Tournament::Team.new('Arizona', 'UA', 10),
+        Tournament::Team.new('Duke', 'Duk', 2),
+        Tournament::Team.new('Belmont', 'Bel', 15)
+      ],
+      3
+    )
+    return pool
+  end
+  
+  def self.test(num_picks = 10)
+    pool = ncaa_2008
+    b = pool.bracket
+    b.scoring_strategy = Tournament::Bracket::UpsetScoringStrategy.new
+    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)])}
+    16.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)])}
+    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)])}
+    picks.each_with_index {|p, idx| pool.add_entry Tournament::Entry.new("picker_#{idx}", p) }
+    picks.each_with_index do |p, idx|
+      puts "Score #{idx+1}: #{p.score_against(b)}"
+    end
+    #pool.possibility_report
+    pool.leader_report
+    pool.entry_report
+  end
+
+  def leader_report
+    puts "Total games played: #{@bracket.games_played}"
+    puts "Number of entries: #{@entries.size}"
+    if @entries.size > 0
+      puts " Curr| Max |               |Champ| Round Scores"
+      puts "Score|Score|      Name     |Live?|" + (1..bracket.rounds).to_a.map{|r| "%3d" % r}.join(" ")
+      sep ="-----+-----+---------------+-----+" + ("-" * 4 * bracket.rounds)
+      puts sep
+      @entries.sort_by {|e| -e.picks.score_against(bracket)}.each do |entry|
+        total = entry.picks.score_against(bracket)
+        max = entry.picks.maximum_score(bracket)
+        champ = entry.picks.champion
+        round_scores = []
+        1.upto(bracket.rounds) do |round|
+          scores = entry.picks.scores_for_round(round, bracket)
+          round_scores << scores.inject(0) {|sum, arr| sum += (arr[0] ? arr[0] : 0)}
+        end
+        puts "%5d|%5d|%15s|%3s %1s|%s" % [total, max, entry.name,
+          champ.short_name,(bracket.still_alive?(champ) ? 'Y' : 'N'), round_scores.map {|s| "%3d" % s}.join(" ")]
+      end
+      puts sep
+    end
+  end
+
+  def score_report
+    # Compute scores
+    puts "Total games played: #{@bracket.games_played}"
+    puts "Number of entries: #{@entries.size}"
+    sep = "-----+---------------+----------------------------------------------------------------------------------"
+    if @entries.size > 0
+      puts "Total|      Name     | Round Scores"
+      puts sep
+      fmt1 = "%5d|%15s|%d: %3d %s" 
+      fmt2 = "     |               |%d: %3d %s" 
+      fmt3 = "     |               |       %s" 
+      @entries.sort_by {|e| -e.picks.score_against(bracket)}.each do |entry|
+        total = entry.picks.score_against(bracket)
+        1.upto(bracket.rounds) do |round|
+          scores = entry.picks.scores_for_round(round, bracket)
+          round_total = scores.inject(0) {|sum, arr| sum += (arr[0] ? arr[0] : 0)}
+          scores_str = scores.map{|arr| "#{arr[1].short_name}=#{arr[0] ? arr[0] : '?'}"}.join(" ")
+          if [1,2].include?(round)
+            scores_str_arr = Tournament::Pool.split_line(scores_str, 70)
+            if round == 1
+              puts fmt1 % [total, entry.name, round, round_total, scores_str_arr[0]]
+            else
+              puts fmt2 % [round, round_total, scores_str_arr[0]]
+            end
+            scores_str_arr[1..-1].each do |scores_str|
+              puts fmt3 % scores_str
+            end
+          else
+            puts fmt2 % [round, round_total, scores_str]
+          end
+        end
+        puts sep
+      end
+    end
+  end
+
+  def self.split_line(str, len)
+    new_str = []
+    beg_idx = 0
+    end_idx = len - 1
+    while end_idx < str.length
+      end_idx += 1 while end_idx < (str.length - 1) && str[end_idx].chr != ' '
+      new_str << str[beg_idx,(end_idx-beg_idx+1)].strip
+      beg_idx = end_idx + 1
+      end_idx += len
+    end
+    new_str << str[beg_idx,str.length-1]
+    return new_str.reject {|s| s.nil? || s.length == 0}  
+  end
+
+  def entry_report
+    puts "There are #{@entries.size} entries."
+    if @entries.size > 0
+      puts "".center(15) + "|" + "First Round".center(128)
+      puts "Name".center(15) + "|" + "Sweet 16".center(64) + "|" + "Elite 8".center(32) +
+        "|" + "Final 4".center(16) + "|" + "Final 2".center(8) + "|" + "Champion".center(15) +
+        "|" + "Tie Break"
+      puts ("-" * 15) + "+" + ("-" * 64) + "+" + ("-" * 32) +
+        "+" + ("-" * 16) + "+" + ("-" * 8) + "+" + ("-" * 15) +
+        "+" + ("-" * 10)
+      output = Proc.new do |name, bracket, tie_breaker|
+        first_round = bracket.winners[1].map {|t| "%s" % (t.short_name rescue 'Unk')}.join('-')
+        sweet_16 = bracket.winners[2].map {|t| "%s" % (t.short_name rescue 'Unk')}.join('-')
+        elite_8 = bracket.winners[3].map {|t| "%s" % (t.short_name rescue 'Unk')}.join('-')
+        final_4 = bracket.winners[4].map {|t| "%s" % (t.short_name rescue 'Unk')}.join('-')
+        final_2 = bracket.winners[5].map {|t| "%s" % (t.short_name rescue 'Unk')}.join('-')
+        champ = bracket.champion.name rescue 'Unk'
+        puts "               |%128s" % first_round
+        puts "%15s|%64s|%32s|%16s|%8s|%15s|%s" %
+          [name, sweet_16, elite_8, final_4, final_2, champ, tie_breaker.to_s] 
+        puts ("-" * 15) + "+" + ("-" * 64) + "+" + ("-" * 32) +
+          "+" + ("-" * 16) + "+" + ("-" * 8) + "+" + ("-" * 15) +
+          "+" + ("-" * 10)
+      end
+
+      output.call('Tournament', bracket, '-')
+
+      @entries.sort_by{|e| e.name}.each do |entry|
+        output.call(entry.name, entry.picks, entry.tie_breaker)
+      end
+    end
+  end
+
+  def region_report
+    puts " Region | Seed | Team               "
+    current_idx = -1
+    @regions.each_with_index do |region, idx|
+      region[:teams].each do |team|
+        region_name = ''
+        if idx != current_idx
+          region_name =  region[:name]
+          current_idx = idx
+          puts "--------+------+-------------------------"
+        end
+        puts "%8s|%6d|%25s" % [region_name, team.seed, "#{team.name} (#{team.short_name})"]
+      end
+    end
+  end
+
+  def possibility_report
+    if @entries.size == 0
+      puts "There are no entries in the pool."
+      return
+    end
+    max_possible_score = @entries.map{|p| 0}
+    min_ranking = @entries.map{|p| @entries.size + 1}
+    times_winner = @entries.map{|p| 0 }
+    count = 0
+    start = Time.now.to_f
+    self.bracket.each_possible_bracket do |poss|
+      poss_scores = @entries.map{|p| p.picks.score_against(poss)}
+      sort_scores = poss_scores.sort.reverse
+      @entries.each_with_index do |entry, i|
+        score = poss_scores[i]
+        max_possible_score[i] = score if score > max_possible_score[i]
+        rank = sort_scores.index(score) + 1
+        min_ranking[i] = rank if rank < min_ranking[i]
+        times_winner[i] += 1 if rank == 1
+      end
+      count += 1
+      percentage = (count * 100 / self.bracket.number_of_outcomes) * 1000
+      if (percentage % 1000) == 0
+        percentage /= 1000
+        hashes = '#' * percentage + '>'
+        elapsed = Time.now.to_f - start
+        spp = elapsed / count
+        remaining = ((self.bracket.number_of_outcomes - count) * spp).to_i
+        print "\rCalculating: %3d%% +#{hashes.ljust(100, '-')}+ %5d seconds remaining" % [percentage, remaining]
+
+      end
+    end
+    puts "\n"
+    #puts "\n   Max Scores: #{max_possible_score.inspect}"
+    #puts "Highest Place: #{min_ranking.inspect}"
+    #puts " Times Winner: #{times_winner.inspect}"
+    sort_array = []
+    times_winner.each_with_index { |n, i| sort_array << [n, i, min_ranking[i], max_possible_score[i]] }
+    sort_array = sort_array.sort_by {|arr| arr[0] == 0 ? (arr[2] == 0 ? -arr[3] : arr[2]) : -arr[0]}
+    #puts "SORT: #{sort_array.inspect}"
+    puts "    Entry           | Win Chance | Highest Place | Max Score | Tie Break  "
+    puts "--------------------+------------+---------------+-----------+------------"
+    sort_array.each do |arr|
+      chance = arr[0].to_f * 100.0 / self.bracket.number_of_outcomes
+      puts "%19s | %10.2f | %13d | %9d | %d" %
+        [@entries[arr[1]].name, chance, min_ranking[arr[1]], max_possible_score[arr[1]], @entries[arr[1]].tie_breaker]
+    end
+  end
+
+end

data/lib/tournament/team.rb

@@ -0,0 +1,19 @@
+# Represents a team in a tournament Bracket
+class Tournament::Team
+  attr_reader :name, :short_name, :seed
+  
+  def initialize(name, short_name, seed)
+    @name = name
+    @short_name = short_name
+    @seed = seed
+  end
+
+  def ==(other)
+    return false unless Tournament::Team === other
+    @name == other.name && @short_name == other.short_name && @seed == other.seed
+  end
+
+  def eql?(other)
+    @name.eql?(other)
+  end
+end

data/lib/tournament.rb

@@ -0,0 +1,56 @@
+# $Id$
+
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? Tournament
+
+module Tournament
+
+  # :stopdoc:
+  VERSION = '1.0.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, *args)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, *args)
+  end
+
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module Tournament
+
+Tournament.require_all_libs_relative_to __FILE__
+
+end  # unless defined?
+
+# EOF

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# $Id$
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib tournament]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

data/spec/tournament_spec.rb

@@ -0,0 +1,8 @@
+# $Id$
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Tournament do
+end
+
+# EOF

data/tasks/ann.rake

@@ -0,0 +1,76 @@
+# $Id$
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  file PROJ.ann_file do
+    puts "Generating #{PROJ.ann_file}"
+    File.open(PROJ.ann_file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      PROJ.ann_paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts PROJ.ann_text if PROJ.ann_text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => PROJ.ann_file
+
+  desc "Send an email announcement"
+  task :email => PROJ.ann_file do
+    from = PROJ.ann_email[:from] || PROJ.email
+    to   = Array(PROJ.ann_email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{PROJ.ann_email[:domain]}>\n\n"
+    rfc822msg << File.read(PROJ.ann_file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      PROJ.ann_email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann_file
+
+# EOF

data/tasks/annotations.rake

@@ -0,0 +1,22 @@
+# $Id$
+
+if HAVE_BONES
+
+desc "Enumerate all annotations"
+task :notes do
+  Bones::AnnotationExtractor.enumerate(
+      PROJ, PROJ.annotation_tags.join('|'), :tag => true)
+end
+
+namespace :notes do
+  PROJ.annotation_tags.each do |tag|
+    desc "Enumerate all #{tag} annotations"
+    task tag.downcase.to_sym do
+      Bones::AnnotationExtractor.enumerate(PROJ, tag)
+    end
+  end
+end
+
+end  # if HAVE_BONES
+
+# EOF

data/tasks/bones.rake

@@ -0,0 +1,40 @@
+# $Id$
+
+require 'pp'
+require 'stringio'
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if ARGV.length == 2
+      t.application.top_level_tasks.pop
+    end
+    sio = StringIO.new
+    sep = "\n" + ' '*27
+    fmt = "%23s => %s"
+
+    if atr
+      PP.pp(PROJ.send(atr.to_sym), sio, 49)
+      sio.seek 0
+      val = sio.read
+      val = val.split("\n").join(sep)
+
+      puts fmt % [atr, val]
+    else
+      h = PROJ.instance_variable_get(:@table)
+      h.keys.map {|k| k.to_s}.sort.each do |k|
+        sio.truncate 0
+        PP.pp(h[k.to_sym], sio, 49)
+        sio.seek 0
+        val = sio.read
+        val = val.split("\n").join(sep)
+
+        puts fmt % [k, val]
+      end
+    end
+  end
+
+end  # namespace :bones
+
+# EOF

data/tasks/doc.rake

@@ -0,0 +1,48 @@
+# $Id$
+
+require 'rake/rdoctask'
+
+namespace :doc do
+
+  desc 'Generate RDoc documentation'
+  Rake::RDocTask.new do |rd|
+    rd.main = PROJ.rdoc_main
+    rd.rdoc_dir = PROJ.rdoc_dir
+
+    incl = Regexp.new(PROJ.rdoc_include.join('|'))
+    excl = Regexp.new(PROJ.rdoc_exclude.join('|'))
+    files = PROJ.files.find_all do |fn|
+              case fn
+              when excl; false
+              when incl; true
+              else false end
+            end
+    rd.rdoc_files.push(*files)
+
+    title = "#{PROJ.name}-#{PROJ.version} Documentation"
+    title = "#{PROJ.rubyforge_name}'s " + title if PROJ.rubyforge_name != title
+
+    rd.options << "-t #{title}"
+    rd.options.concat(PROJ.rdoc_opts)
+  end
+
+  desc 'Generate ri locally for testing'
+  task :ri => :clobber_ri do
+    sh "#{RDOC} --ri -o ri ."
+  end
+
+  task :clobber_ri do
+    rm_r 'ri' rescue nil
+  end
+
+end  # namespace :doc
+
+desc 'Alias to doc:rdoc'
+task :doc => 'doc:rdoc'
+
+desc 'Remove all build products'
+task :clobber => %w(doc:clobber_rdoc doc:clobber_ri)
+
+remove_desc_for_task %w(doc:clobber_rdoc)
+
+# EOF