hangman_tournament 1.0

data/CHANGES

@@ -0,0 +1,6 @@
+= Hangman Tounament Changelog
+
+== Version 1.0
+
+Initial Release
+* FTW

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rake'
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = false
+end
+
+PKG_NAME = "hangman_tournament"
+PKG_VERSION   = "1.0"
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.files = FileList['lib/**/*', 'spec/**/*', 'bin/**/*', 'CHANGES', 'Rakefile'].to_a
+  s.require_path = 'lib'
+  s.test_files = Dir.glob('spec/*_spec.rb')
+  s.bindir = 'bin'
+  s.executables = ['generate_hangman_player', 'submit_hangman_player']
+  s.email = "sparring-hangman@rubyforge.org"
+  s.homepage = "http://sparring.rubyforge.org/"
+  s.rubyforge_project = "sparring"
+  s.summary = "Hangman tournament."
+  s.description = "This gem provides the infrastructure needed to participate in the Hangman Tournament"
+  s.author = "Micah Martin"
+  s.add_dependency('letter_letdown', ">= 1.0")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+task :verify_user do
+  raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
+end
+
+task :verify_password do
+  raise "RUBYFORGE_PASSWORD environment variable not set!" unless ENV['RUBYFORGE_PASSWORD']
+end
+
+task :copy_player_gems do
+  system "cp ../letter_letdown/pkg/hangman_letter_letdown-1.0.gem pkg"
+  system "cp submissions/*.gem pkg"
+end
+
+desc "Publish gem+tgz+zip on RubyForge. You must make sure lib/version.rb is aligned with the CHANGELOG file"
+task :publish_packages => [:verify_user, :verify_password, :package, :copy_player_gems] do
+  require 'meta_project'
+  require 'rake/contrib/xforge'
+  release_files = FileList[
+    "pkg/#{PKG_FILE_NAME}.gem",
+    "pkg/hangman_letter_letdown-1.0.gem"
+  ]
+
+  Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new("sparring")) do |xf|
+    # Never hardcode user name and password in the Rakefile!
+    xf.user_name = ENV['RUBYFORGE_USER']
+    xf.password = ENV['RUBYFORGE_PASSWORD']
+    xf.files = release_files.to_a
+    xf.release_name = "Hangman Tournament #{PKG_VERSION}"
+  end
+end

data/bin/generate_hangman_player

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+player_name = ARGV[0]
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/init")
+require "limelight/templates/player_templater"
+
+templater = Limelight::Templates::PlayerTemplater.new(player_name)
+templater.generate

data/bin/submit_hangman_player

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+player_name = ARGV[0]
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/init")
+require "hangman_tournament/submit"
+
+submitter = HangmanTournament::Submit.new(player_name)
+submitter.submit

data/lib/hangman_tournament/submit.rb

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'digest/sha1'
+require 'drb'
+
+module HangmanTournament
+
+  class Submit
+
+    def initialize(gem_name)
+      @gem_name = gem_name
+      @input = $stdin
+      @output = $stdout
+    end
+
+    def submit
+      data = collect_data
+      password = get_password
+      password = Digest::SHA1.hexdigest(password)
+      data[:password] = password
+
+      begin
+        server = DRbObject.new(nil, 'druby://micahmartin.com:9697')
+        authorized = server.authorize(data[:name], password)
+        quit "Incorrect password.  You are not authorized to submit this player." unless authorized
+        result = server.submit_profile(data)
+        quit "Failed to submit: #{result}" if result != true
+        puts "Player #{data[:name]} has been submitted."
+      rescue DRb::DRbConnError => e
+        quit "Could not connect to battleship server!"
+      end
+    end
+
+    def collect_data
+      spec = gem_spec
+      data = {}
+      data[:name] = spec.summary[15..-1]
+      data[:author] = spec.author
+      data[:email] = spec.email
+      data[:description] = spec.description
+      data[:gem_file_name] = spec.file_name     
+      gem_file_path = File.expand_path(File.join(spec.full_gem_path, "..", "..", 'cache', spec.file_name))
+      data[:gem_content] = IO.read(gem_file_path)
+      return data
+    end
+
+    def gem_spec
+      if @spec.nil?
+        @spec = Gem.source_index.latest_specs.find do |spec|
+          spec.name == @gem_name
+        end
+      end
+      quit "Could not find installed gem named '#{@gem_name}'" if @spec.nil?
+      return @spec
+    end
+
+    def get_password
+      @output.puts "Password?"
+      @output.print "> "
+
+      password = @input.readline.strip
+      return password
+    end
+
+    def quit(message)
+      puts message
+      exit -1
+    end
+
+  end
+
+end

data/lib/init.rb

@@ -0,0 +1 @@
+$: << File.expand_path(File.dirname(__FILE__))

data/lib/limelight/string.rb

@@ -0,0 +1,35 @@
+class String
+
+  # Converts Ruby style names to Java style camal case.
+  #
+  #   "four_score".camalized # => "FourScore"
+  #   "and_seven_years".camalized(:lower) # => "andSevenYears"
+  #
+  def camalized(starting_case = :upper)
+    value = self.downcase.gsub(/[_| ][a-z]/) { |match| match[-1..-1].upcase }
+    value = value[0..0].upcase + value[1..-1] if starting_case == :upper
+    return value
+  end
+
+  # Converts Java camel case names to ruby style underscored names.
+  #
+  #   "FourScore".underscored # => "four_score"
+  #   "andSevenYears".underscored # => "and_seven_years"
+  #
+  def underscored
+    value = self[0..0].downcase + self[1..-1]
+    value = value.gsub(/[A-Z]/) { |cap| "_#{cap.downcase}" }
+    return value
+  end
+
+
+  # Converts ruby style and camalcase strings into title strings where every word is capitalized and separated by a space.
+  #
+  #   "four_score".titleized # => "Four Score"
+  #
+  def titleized(starting_case = :upper)
+    value = self.gsub(/[a-z0-9][A-Z]/) { |match| "#{match[0..0]} #{match[-1..-1]}" }
+    value = value.gsub(/[_| ][a-z]/) { |match| " #{match[-1..-1].upcase}" }
+    return value[0..0].upcase + value[1..-1]
+  end
+end

data/lib/limelight/templates/player_templater.rb

@@ -0,0 +1,33 @@
+require 'limelight/templates/templater'
+require 'limelight/string'
+
+module Limelight
+  module Templates
+
+    class PlayerTemplater < Templater
+
+      attr_reader :filename, :tokens
+
+      def initialize(player_name)
+        super(".")
+        @tokens = {}
+        @tokens[:PLAYER_NAME] = player_name
+        clean_name = player_name.gsub(/[\?\*!'\-.;:]/, "").gsub(" ", "_").downcase
+        @filename = @tokens[:FILENAME] = clean_name
+        @tokens[:CLASSNAME] = clean_name.camalized
+      end
+
+      # Generates the files
+      #
+      def generate
+        file(File.join(filename, "Rakefile"), "Rakefile.template", @tokens)
+        file(File.join(filename, "Hangman.Rakefile"), "Hangman.Rakefile.template", @tokens)
+        file(File.join(filename, "lib", filename, "#{filename}.rb"), "player.template", @tokens)
+        file(File.join(filename, "spec", "spec_helper.rb"), "spec_helper.template", @tokens) 
+        file(File.join(filename, "spec", filename, "#{filename}_spec.rb"), "player_spec.template", @tokens)
+      end
+
+    end
+
+  end
+end

data/lib/limelight/templates/sources/Hangman.Rakefile.template

@@ -0,0 +1,12 @@
+#
+# DO NOT tamper with this file.  It will lead to disqualification.
+
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('spec_with_rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = true
+  t.rcov_opts = ['-t', '--exclude', 'spec,rcov', '--no-html']
+end

data/lib/limelight/templates/sources/Rakefile.template

@@ -0,0 +1,47 @@
+require 'rake'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+require 'hangman_tournament/submit'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = false
+end
+
+PKG_NAME = "!-FILENAME-!"
+PKG_VERSION   = "1.0"
+
+spec = Gem::Specification.new do |s|
+  s.name = "hangman_#{PKG_NAME}"
+  s.version = PKG_VERSION
+  s.files = Dir.glob('**/*').reject{ |f| f =~ /pkg/ }
+  s.require_path = 'lib'
+  s.test_files = Dir.glob('spec/*_spec.rb')
+  s.bindir = 'bin'
+  s.executables = []
+  s.summary = "Hangman Player:!-PLAYER_NAME-!"
+  s.rubyforge_project = "sparring"
+  s.homepage = "http://sparring.rubyforge.org/"
+
+  ###########################################
+  ##
+  ## You are encouraged to modify the following
+  ## spec attributes.
+  ##
+  ###########################################
+  s.description = "A hangman player"
+  s.author = "Anonymous"
+  s.email = "authors@email.com"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+desc "Submit your player"
+task :submit do
+  submitter = HangmanTournament::Submit.new(PKG_NAME)
+  submitter.submit
+end

data/lib/limelight/templates/sources/bs_player.template

@@ -0,0 +1,169 @@
+module !-CLASSNAME-!
+
+  # Battleship Player
+  #
+  # Battleship is board game between two players.  See http://en.wikipedia.org/wiki/Battleship for more information and
+  # game rules.
+  #
+  # A player represents the conputer AI to play a game of Battleship.  It should know how to place ships and target
+  # the opponents ships.
+  #
+  # This version of Battleship is played on a 10 x 10 grid where rows are labled by the letters A - J and
+  # columns are labled by the numbers 1 - 10.  At the start of the game, each player will be asked for ship placements.
+  # Once the ships are placed, play proceeeds by each player targeting one square on their opponents map.  A player
+  # may only target one square, reguardless of whether it resulted in a hit or not, before changing turns with her opponent.
+  #
+  class !-CLASSNAME-!
+
+    # This method is called at the beginning of each game.  A player may only be instantiated once and used to play many games.
+    # So new_game should reset any internal state acquired in previous games so that it is prepared for a new game.
+    #
+    # The name of the opponent player is passed in.  This allows for the possibility to learn opponent strategy and
+    # play the game differently based on the opponent.
+    #
+    def new_game(opponent_name)
+      reset
+    end
+
+    # Returns the placement of the carrier. A carrier consumes 5 squares.
+    #
+    # The return value is a string that describes the placements of the ship.
+    # The placement string must be in the following format:
+    #
+    #   "#{ROW}#{COL} #{ORIENTATION}"
+    #
+    # eg
+    #
+    #   A1 horizontal # the ship will occupy A1, A2, A3, A4, and A5
+    #   A1 vertical # the ship will occupy A1, B1, C1, D1, and E1
+    #   F5 horizontal # the ship will occupy F5, F6, F7, F8, and F9
+    #   F5 vertical # the ship will occupy F5, G5, H5, I5, and J5
+    #
+    # The ship must not fall off the edge of the map.  For example, a carrier placement of 'A8 horizontal' would
+    # not leave enough space in the A row to accomidate the carrier since it requires 5 squares.
+    #
+    # Ships may not overlap with other ships.  For example a carrier placement of 'A1 horizontal' and a submarine
+    # placement of 'A1 vertical' would be invalid because bothe ships are trying to occupy the square A1.
+    #
+    # Invalid ship placements will result in disqualification of the player.
+    #
+    def carrier_placement
+      return "A1 horizontal"
+    end
+
+    # Returns the placement of the battleship. A battleship consumes 4 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def battleship_placement
+      return "B1 horizontal"
+    end
+
+    # Returns the placement of the destroyer. A destroyer consumes 3 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def destroyer_placement
+      return "C1 horizontal"
+    end
+
+    # Returns the placement of the submarine. A submarine consumes 3 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def submarine_placement
+      return "D1 horizontal"
+    end
+
+    # Returns the placement of the patrolship. A patrolship consumes 2 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def patrolship_placement
+      return "E1 horizontal"
+    end
+
+    # Returns the coordinates of the players next target.  This method will be called once per turn.  The player
+    # should return target coordinates as a string in the form of:
+    #
+    #   "#{ROW}#{COL}"
+    #
+    # eg
+    #
+    #   A1 # the square in Row A and Column 1
+    #   F5 # the square in Row F and Column 5
+    #
+    # Since the map contains only 10 rows and 10 columns, the ROW should be A, B, C, D, E, F, G H, I, or J. And the
+    # COL should be 1, 2, 3, 4, 5, 6, 7, 8, 9, or 10
+    #
+    # Returning coordinates outside the range or in an invalid format will result in the players disqualification.
+    #
+    # It is illegal to illegal to target a sector more than once.  Doing so will also result in disqualification.
+    #
+    def next_target
+      target = target_for_current_shot
+      @shots_taken += 1
+      return target
+    end
+
+    # target_result will be called by the system after a call to next_target.  The paramters supplied inform the player
+    # of the results of the target.
+    #
+    #   coordinates : string. The coordinates targeted.  It will be the same value returned by the previous call to next_target
+    #   was_hit     : boolean.  true if the target was occupied by a ship.  false otherwise.
+    #   ship_sunk   : symbol.  nil if the target did not result in the sinking of a ship.  If the target did result in
+    #     in the sinking of a ship, the ship type is supplied (:carrier, :battleship, :destroyer, :submarine, :patrolship).
+    #
+    # An intelligent player will use the information to better play the game.  For example, if the result indicates a
+    # hit, a player my choose to target neighboring squares to hit and sink the remainder of the ship.
+    #
+    def target_result(coordinates, was_hit, ship_sunk)
+    end
+
+    # enemy_targeting is called by the system to inform a player of their apponents move.  When the opponent targets
+    # a square, this method is called with the coordinates.
+    #
+    # Players may use this information to understand an opponents targeting strategy and place ships differently
+    # in subsequent games.
+    #
+    def enemy_targeting(coordinates)
+    end
+
+    # Called by the system at the end of a game to inform the player of the results.
+    #
+    #   result  : 1 of 3 possible values (:victory, :defeate, :disqualified)
+    #   disqualification_reason : nil unless the game ended as the result of a disqualification.  In the event of a
+    #     disqualification, this paramter will hold a string description of the reason for disqualification.  Both
+    #     players will be informed of the reason.
+    #
+    #   :victory # indicates the player won the game
+    #   :defeat # indicates the player lost the game
+    #   :disqualified # indicates the player was disqualified
+    #
+    def game_over(result, disqualification_reason=nil)
+    end
+
+    # Non API methods #####################################
+
+    attr_reader :opponent, :targets, :enemy_targeted_sectors, :result, :disqualification_reason #:nodoc:
+
+    def initialize #:nodoc:
+      reset
+    end
+
+    private ###############################################
+
+    def reset
+      @shots_taken = 0
+    end
+
+    ROWS = %w{ A B C D E F G H I J }
+    def target_for_current_shot
+      row = ROWS[(@shots_taken) / 10]
+      col = @shots_taken % 10 + 1
+      return "#{row}#{col}"
+    end
+
+  end
+
+end

data/lib/limelight/templates/sources/player.template

@@ -0,0 +1,45 @@
+module !-CLASSNAME-!
+  class !-CLASSNAME-!
+
+    # You may initialize you player but the the initialize method must take NO paramters.
+    # The player will only be instantiated once, and will play many games.
+    def initialize
+    end
+
+    # Before starting a game, this method will be called to inform the player of all the possible words that may be
+    # played.
+    def word_list=(list)
+    end
+
+    # a new game has started.  The number of guesses the player has left is passed in (default 6),
+    # in case you want to keep track of it.
+    def new_game(guesses_left)
+      @left = ('a'..'z').to_a
+    end
+
+    # Each turn your player must make a guess.  The word will be a bunch of underscores, one for each letter in the word.
+    # after your first turn, correct guesses will appear in the word parameter.  If the word was "shoes" and you guessed "s",
+    # the word parameter would be "s___s", if you then guess 'o', the next turn it would be "s_o_s", and so on.
+    # guesses_left is how many guesses you have left before your player is hung.
+    def guess(word, guesses_left)
+      @left.shift
+    end
+
+    # notifies you that your last guess was incorrect, and passes your guess back to the method
+    def incorrect_guess(guess)
+    end
+
+    # notifies you that your last guess was correct, and passes your guess back to the method
+    def correct_guess(guess)
+    end
+
+    # you lost the game.  The reason is in the reason parameter
+    def fail(reason)
+    end
+
+    # The result of the game, it'll be one of 'win', 'loss', or 'fail'.
+    # The spelled out word will be provided regardless of the result.
+    def game_result(result, word)
+    end
+  end
+end

data/lib/limelight/templates/sources/player_spec.template

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require '!-FILENAME-!/!-FILENAME-!'
+
+describe !-CLASSNAME-!::!-CLASSNAME-! do
+
+  it "should be instantiable with no paramters" do
+
+    lambda { !-CLASSNAME-!::!-CLASSNAME-!.new }.should_not raise_error
+
+  end
+
+end

data/lib/limelight/templates/sources/spec_helper.template

@@ -0,0 +1,4 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'spec'

data/lib/limelight/templates/templater.rb

@@ -0,0 +1,128 @@
+require 'limelight/templates/templater_logger'
+
+module Limelight
+  module Templates
+
+    # A class to create directories and file templates.  An instance of Templater must be provided with
+    # a target_root and a source_root.  The target_root designates a root directory in which all directories and
+    # files will be created.  The source_root designated a directory where all the file template can be found.
+    #
+    # A file template is a plain text file.  It may optionally contain token markers in the format !-TOKEN_NAME-!.
+    # When a file template is installed by the templater, all the token margers will be replaced by tokens provided
+    # in a hash.
+    #
+    class Templater
+
+      # Return the default source_root for Limelight related file templates.
+      #
+      # $LIMELIGHT_LIB$/limelight/templates/sources
+      #
+      def self.source_dir
+        return File.join(File.dirname(__FILE__), "sources")
+      end
+
+      # Carifies a path as relative or absolute.  Essentially if makes sure a path begins with a . if it's not
+      # an absolute path.
+      #
+      #   Templater.clarity('some/path') -> './some/path'
+      #   Templater.clarity('/root/path') -> '/root/path'
+      #
+      def self.clarify(path)
+        return path if path[0..0] == '.'
+        return path if path == File.expand_path(path)
+        return File.join(".", path)
+      end
+
+      attr_reader :target_root, :source_root
+
+      # See TemplaterLogger 
+      #
+      attr_accessor :logger
+
+      # New instances Templater require a target_root.  The source_root may optionally be provided.  source_root
+      # defaults to Templater.source_dir
+      #
+      # The logger is initializes as a TemplaterLogger
+      #
+      def initialize(target_root, source_root=Templater.source_dir)
+        @logger = TemplaterLogger.new
+        @target_root = Templater.clarify(target_root)
+        @source_root = source_root
+      end
+
+      # Creates a deirectory.  If the specified directory's parent directory is missing, it will be created as will its
+      # parent directory, and so on.
+      #
+      # After the following call,
+      #
+      #   templater.directory("dir1/dir2/dir3/dir4")
+      #
+      # The following directories will exist, inside the target_root, whether they existed prior to the call or not.
+      #
+      #   dir1
+      #   dir1/dir2
+      #   dir1/dir2/dir3
+      #   dir1/dir2/dir3/dir4
+      #
+      def directory(path)
+        full_path = File.join(@target_root, path)
+        establish_directory(full_path)
+      end
+
+      # Creates the specified file from the specified file template.  The file will be created withint the target_root.
+      # All parent diretories will be created if needed.  The source paramter should be a path pointing to a
+      # file template in the source_root directory.
+      #
+      # Assume the the file <code>src/default.txt.template</code> exists in the source_root with the following content.
+      #
+      #   !-SCORES-! score and !-YEARS-! years ago, ...
+      #
+      # When the following command is executed,
+      #
+      #   templater.file('dir/foo.txt', 'src/default.txt.template', :SCORES => "Four", :YEARS => "seven")
+      #
+      # The file <code>dir/foo.txt</code> will exist in the target_root with the following content.
+      #
+      #   Four score and seven years ago, ...
+      #
+      def file(target, source, tokens = {})
+        target_path = File.join(@target_root, target)
+        source_source = File.join(@source_root, source)
+
+        establish_directory(File.dirname(target_path))
+
+        if File.exists?(target_path)
+          @logger.file_already_exists(target_path)
+        else
+          @logger.creating_file(target_path)
+          content = IO.read(source_source)
+          content = replace_tokens(content, tokens)
+          File.open(target_path, 'w') { |file| file.write content }
+        end
+      end
+
+      private
+
+      def establish_directory(full_path)
+        return if File.exists?(full_path)
+        parent_path = File.dirname(full_path)
+        while (!File.exists?(parent_path))
+          establish_directory(parent_path)
+        end
+
+        @logger.creating_directory(full_path)
+        Dir.mkdir(full_path)
+      end
+
+      def replace_tokens(content, tokens)
+        return content.gsub(/!-(\w+)-!/) do |value|
+          token_name = value[2...-2]
+          token = tokens[token_name] || tokens[token_name.to_sym] || "UNKNOWN TOKEN"
+          token
+        end
+      end
+
+    end
+
+  end
+end

data/lib/limelight/templates/templater_logger.rb

@@ -0,0 +1,36 @@
+module Limelight
+  module Templates
+
+    # Templaters uses this class to log activity.  
+    #
+    class TemplaterLogger
+
+      # An accessor to the output IO. Defaults to STDOUT
+      #
+      attr_accessor :output
+
+      def initialize
+        @output = STDOUT
+      end
+
+      def creating_directory(name)
+        @output.puts "\tcreating directory:  #{name}"
+      end
+
+      def creating_file(name)
+        @output.puts "\tcreating file:       #{name}"
+      end
+
+      def file_already_exists(name)
+        @output.puts "\tfile already exists: #{name}"
+      end
+
+      def log(message, name)
+        spaces = 21 - message.length - 1
+        @output.puts "\t#{message}:#{' '*spaces}#{name}"
+      end
+
+    end
+    
+  end
+end

data/spec/hangman_tournament/submit_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'hangman_tournament/submit'
+
+describe HangmanTournament::Submit do
+
+  before(:all) do
+    ENV['GEM_PATH'] = '/opt/local/lib/ruby/gems/1.8'
+    Gem.clear_paths
+  end
+
+  before(:each) do
+    @submit = HangmanTournament::Submit.new("letter_letdown")
+  end
+
+  it "should read a gem file" do
+    result = @submit.collect_data
+
+    result[:name].should == "Letter Letdown"
+    result[:author].should == "Micah Martin"
+    result[:email].should == "micah@8thlight.com"
+    result[:description].should == "A very simple player."
+    result[:gem_file_name].should == "letter_letdown-1.0.gem"
+    result[:gem_content].should == IO.read("/opt/local/lib/ruby/gems/1.8/cache/letter_letdown-1.0.gem")
+  end
+
+  it "should get password" do
+    $stdout.should_receive(:puts).with("Password?")
+    $stdout.should_receive(:print).with("> ")
+    $stdin.should_receive(:readline).and_return("blah")
+
+    password = @submit.get_password
+
+    password.should == "blah"
+  end
+
+end

data/spec/limelight/templates/player_templater_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+require 'limelight/templates/player_templater'
+
+describe Limelight::Templates::PlayerTemplater do
+
+  it "should know names" do
+    templater = Limelight::Templates::PlayerTemplater.new("Simple Bot")
+
+    templater.filename.should == "simple_bot"
+    templater.tokens[:CLASSNAME].should == "SimpleBot"
+    templater.tokens[:PLAYER_NAME].should == "Simple Bot"
+  end
+
+  it "should know names with a little punctuation" do
+    templater = Limelight::Templates::PlayerTemplater.new("Satan's Revenge!")
+
+    templater.filename.should == "satans_revenge"
+    templater.tokens[:CLASSNAME].should == "SatansRevenge"
+    templater.tokens[:PLAYER_NAME].should == "Satan's Revenge!"
+  end
+
+  it "should know names with a lot of punctuation" do
+    templater = Limelight::Templates::PlayerTemplater.new("Bl'ah? *Bl-!ah.;")
+
+    templater.filename.should == "blah_blah"
+    templater.tokens[:CLASSNAME].should == "BlahBlah"
+    templater.tokens[:PLAYER_NAME].should == "Bl'ah? *Bl-!ah.;"
+  end
+
+  it "should generate files" do
+    templater = Limelight::Templates::PlayerTemplater.new("Simple Bot")
+
+    templater.should_receive(:file).with("simple_bot/Rakefile", "Rakefile.template", anything)
+    templater.should_receive(:file).with("simple_bot/Hangman.Rakefile", "Hangman.Rakefile.template", anything)
+    templater.should_receive(:file).with("simple_bot/lib/simple_bot/simple_bot.rb", "player.template", anything)
+    templater.should_receive(:file).with("simple_bot/spec/spec_helper.rb", "spec_helper.template", anything)
+    templater.should_receive(:file).with("simple_bot/spec/simple_bot/simple_bot_spec.rb", "player_spec.template", anything)
+
+    templater.generate
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib")

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: hangman_tournament
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Micah Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-17 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: letter_letdown
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+description: This gem provides the infrastructure needed to participate in the Hangman Tournament
+email: sparring-hangman@rubyforge.org
+executables: 
+- generate_hangman_player
+- submit_hangman_player
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/hangman_tournament
+- lib/hangman_tournament/submit.rb
+- lib/init.rb
+- lib/limelight
+- lib/limelight/string.rb
+- lib/limelight/templates
+- lib/limelight/templates/player_templater.rb
+- lib/limelight/templates/sources
+- lib/limelight/templates/sources/bs_player.template
+- lib/limelight/templates/sources/Hangman.Rakefile.template
+- lib/limelight/templates/sources/player.template
+- lib/limelight/templates/sources/player_spec.template
+- lib/limelight/templates/sources/Rakefile.template
+- lib/limelight/templates/sources/spec_helper.template
+- lib/limelight/templates/templater.rb
+- lib/limelight/templates/templater_logger.rb
+- spec/hangman_tournament
+- spec/hangman_tournament/submit_spec.rb
+- spec/limelight
+- spec/limelight/templates
+- spec/limelight/templates/player_templater_spec.rb
+- spec/spec_helper.rb
+- bin/generate_hangman_player
+- bin/submit_hangman_player
+- CHANGES
+- Rakefile
+has_rdoc: false
+homepage: http://sparring.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: sparring
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Hangman tournament.
+test_files: []
+