hangbot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f969e132a38464aae0acc5df407ea42e65211774
+  data.tar.gz: e7a1c16248085b07d4a54d705703babf5eb75c58
+SHA512:
+  metadata.gz: 98296a0e5329e0231a62d1d57caa8f97bcc0e5f7ce01d7d3954902b120fcb3e50e2b2722608b5adf650841db63b9f4f35928b794f10742f5a9514c0e08d5a994
+  data.tar.gz: c8edfab2fb1eb49984bca434be6f0043e4da37e76a0097219371e200223df64ed81a17b4ca388b74ae551d6e46d85da87eeb76bfa647afbdc86c6903e1450bd7

data/.gitignore

@@ -0,0 +1 @@
+hangbot.yaml

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p451

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: .
+  specs:
+    hangbot (0.1.0)
+      configliere (~> 0.4)
+      httparty (~> 0.13)
+      json (~> 1.8)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    coderay (1.1.0)
+    configliere (0.4.18)
+      highline (>= 1.5.2)
+      multi_json (>= 1.1)
+    ffi (1.9.3)
+    formatador (0.2.5)
+    guard (2.6.1)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-minitest (2.3.1)
+      guard (~> 2.0)
+      minitest (>= 3.0)
+    highline (1.6.21)
+    httparty (0.13.1)
+      json (~> 1.8)
+      multi_xml (>= 0.5.2)
+    json (1.8.1)
+    listen (2.7.9)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    minitest (5.4.0)
+    multi_json (1.10.1)
+    multi_xml (0.5.5)
+    pry (0.10.0)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.1.1)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    slop (3.6.0)
+    thor (0.19.1)
+    timers (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  guard
+  guard-minitest
+  hangbot!
+  rake

data/Guardfile

@@ -0,0 +1,7 @@
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest, include: ['lib'], cli: '--pride' do
+   watch(%r{^spec/(.*)_spec\.rb$})
+   watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+   watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Josh Strater
+
+MIT License
+
+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.md

@@ -0,0 +1,40 @@
+**hangbot** is
+
+1. a way for me to try out the HipChat v2 API & webhooks
+2. a shared hangman-style game for HipChat rooms
+
+## Setup
+
+### From Rubygems
+
+Requires Ruby >= 2.0.
+
+1. `$ gem install hangbot`
+
+### From GitHub
+
+Requires Ruby >= 2.0 and Bundler.
+
+1. `$ git clone git@github.com:jstrater/hangbot.git`
+2. `$ cd hangbot`
+3. `$ bundle install`
+
+## Configuration
+
+hangbot's configuration lives in a YAML file. You can use `example.hangbot.yaml` as a template for your config. Fill in the appropriate values for your environment, including your HipChat API key, room name, and externally visible server URL.
+
+### Tips
+
+   - You'll need a HipChat API token with `admin_room` and `send_notification` scopes for the selected room.
+   - Pay attention to the `local_server.base_url` field -- this is the address that HipChat's webhooks will use to notify the local server about new messages, and if you're behind a firewall or router, you'll want to make sure that it's reachable from the outside world.
+
+## How to play
+
+Start the server by running `$ hangbot hangbot.yaml` (assuming that you put your configuration in `hangbot.yaml`.)
+
+Once hangbot is running, type `/hangbot` in your HipChat room to start a new game. Use `/guess L` to guess a letter (where `L` is any letter of the alphabet.)
+
+## TODO
+
+- Automatic router traversal
+- Put in friendlier error messages

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+Rake::TestTask.new do |t|
+   t.test_files = FileList['spec/*_spec.rb']
+end

data/bandnames.txt

@@ -0,0 +1,131 @@
+Abba
+Ace of Base
+Adele
+Aerosmith
+Al Green
+Alanis Morissette
+Avril Lavigne
+Barbra Streisand
+Bee Gees
+Beyonce
+Billy Ocean
+Blondie
+Boney M
+Boyz II Men
+Britney Spears
+Bruce Springsteen
+Bruno Mars
+Bryan Adams
+Celine Dion
+Cher
+Chic
+Chicago
+Christina Aguilera
+Coldplay
+Color Me Badd
+Coolio
+Creedence Clearwater Revival
+Culture Club
+Cyndi Lauper
+David Bowie
+Destiny's Child
+Diana Ross
+Don McLean
+Donna Summer
+Eagles
+Earth Wind and Fire
+Elton John
+Eminem
+Eric Clapton
+Falco
+Fergie
+Fine Young Cannibals
+Fleetwood Mac
+Frankie Goes To Hollywood
+George Harrison
+George McCrae
+George Michael
+Gilbert O'Sullivan
+Glee Cast
+Green Day
+Gwen Stefani
+Haddaway
+Hanson
+Harry Nilsson
+INXS
+Irene Cara
+J Geils Band
+Janet Jackson
+Jennifer Lopez
+John Lennon
+Justin Timberlake
+Katy Perry
+Kim Carnes
+Kylie Minogue
+Lady GaGa
+Leona Lewis
+Linkin Park
+MC Hammer
+Madonna
+Mariah Carey
+Men At Work
+Michael Jackson
+Mika
+N Sync
+Nelly
+Nelly Furtado
+New Kids On The Block
+Nickelback
+Nirvana
+Oasis
+Offspring
+Paula Abdul
+Pink
+Pink Floyd
+Prince
+Pussycat
+Queen
+REM
+Red Hot Chili Peppers
+Rick Astley
+Ricky Martin
+Rihanna
+Rod Stewart
+Roxette
+Shakira
+Sheena Easton
+Shocking Blue
+Sinead O'Connor
+Slade
+Smokie
+Snap
+Spice Girls
+Starsound
+Stevie Wonder
+Survivor
+T Rex
+TLC
+Taylor Swift
+Tears For Fears
+Terry Jacks
+The Backstreet Boys
+The Bangles
+The Bay City Rollers
+The Beatles
+The Black Eyed Peas
+The Fugees
+The Human League
+The Pet Shop Boys
+The Police
+The Pussycat Dolls
+The Rolling Stones
+The Rubettes
+The Sweet
+The Village People
+Tiffany
+USA For Africa
+Usher
+Wham
+Whitney Houston
+Wings
+tATu

data/bin/hangbot

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+# Make sure lib/ is in the include path
+lib_path = File.expand_path '../lib', File.dirname(__FILE__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+require 'hangbot'

data/example.hangbot.yaml

@@ -0,0 +1,21 @@
+# By default, hangbot will use its own default wordlist. If you'd like to use
+# your own, set word_list.
+#word_list: bandnames.txt
+
+local_server:
+   # The address for the local webhook listening server to bind to. 
+   bind_address: 0.0.0.0
+   port: 4567
+
+   # This is the URI to access your local server from the outside world
+   # (accounting for NAT, port forwarding, etc.)
+   base_url: http://1.2.3.4:4567
+
+hipchat:
+   room_name: my_hipchat_room
+
+   # The token must have admin_room and send_notification scopes for the room.
+   api_token: mYH1pCh47t0k3N
+
+   # Seconds before an API request times out.
+   timeout: 2

data/hangbot.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+Gem::Specification.new do |spec|
+   spec.name          = "hangbot"
+   spec.version       = "0.1.0"
+   spec.authors       = ["Josh Strater"]
+   spec.email         = ["jstrater@gmail.com"]
+   spec.summary       = %q{Hangman for HipChat}
+   spec.description   = %q{Small Hangman game for HipChat. Uses the v2 API and webhooks.}
+   spec.homepage      = "https://github.com/jstrater/hangbot"
+   spec.license       = "MIT"
+ 
+   spec.files         = `git ls-files -z`.split("\x0")
+   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+   spec.require_paths = ["lib"]
+ 
+   spec.add_development_dependency "bundler", "~> 1.6"
+   spec.add_development_dependency "rake", "~> 10.0"
+   spec.add_development_dependency "guard", "~> 2.6"
+   spec.add_development_dependency "guard-minitest", "~> 2.3"
+ 
+   spec.add_runtime_dependency "httparty", "~> 0.13"
+   spec.add_runtime_dependency "json", "~> 1.8"
+   spec.add_runtime_dependency "configliere", "~> 0.4"
+end

data/lib/hangbot.rb

@@ -0,0 +1,213 @@
+require 'webrick'
+require 'json'
+require 'hipchat_party'
+require 'uri'
+require 'pp'
+require 'configliere'
+require 'logger'
+require 'hangman_game'
+require 'hangman_wordlist'
+
+
+# Set up a webhook and make sure any old leftover hooks are cleaned out
+def init_hipchat_webhook hipchat, room_name, webhook_name, url
+   remove_hipchat_webhooks hipchat, room_name, webhook_name
+
+   return hipchat.create_webhook(
+      room_name,
+      webhook_name,
+      'room_message',
+      url,
+      pattern:'^\/(hangman|guess).*'
+   )
+end
+
+# Clean out all HipChat webhooks with webhook_name.
+def remove_hipchat_webhooks hipchat, room_name, webhook_name
+   hipchat.delete_webhooks_by_name room_name, webhook_name
+end
+
+# Create a web server that listens on the given address & port for HipChat
+# message notifications. The webhook ID on the notifications will be checked
+# against +webhook_id+.
+#
+# Message contents will be passed to the block, and the block's return value
+# will be posted as a new HipChat room notification.
+def respond_to_hipchat_messages port:4567, address:'0.0.0.0', room_name:nil,
+   webhook_url:nil, api_token:nil, timeout:30, logger:nil
+   webhook_name = 'hangbot'
+
+   # Tell HipChat to let us know when there's a new message in the room
+   hipchat = HipChatParty.new api_token, timeout:timeout
+   logger.info "Setting up a new HipChat webhook and clearing out old ones"
+   webhook_id = init_hipchat_webhook hipchat, room_name, webhook_name, webhook_url
+
+   # Create a WEBrick server to listen for HipChat notifications.
+   #
+   # For better security, you could get a cert and use it to run WEBrick in HTTPS mode.
+   server = WEBrick::HTTPServer.new Port:port, BindAddress:address
+   server.mount_proc '/' do |req, res|
+      body = JSON.parse(req.body)
+
+      # Check to see if this is the hook that we're expecting
+      unless body['event'] == 'room_message' && body['webhook_id'] == webhook_id
+         logger.warn "Unexpected webhook callback from #{req.remote_ip}"
+         logger.debug "#{body.inspect}"
+         next
+      end
+
+      # Let the block come up with a response to the message
+      sender = body['item']['message']['from']['mention_name']
+      message = body['item']['message']['message']
+      logger.info "message: #{sender}: #{message}"
+      response_message = yield message
+
+      # Send the block's response back to the room
+      if response_message
+         logger.info "response: #{response_message}"
+         hipchat.send_room_notification room_name, response_message
+      else
+         logger.info "no response"
+      end
+   end
+
+   # Shut down cleanly on ctrl-c
+   trap 'INT' do
+      # Reset the signal handler so that two SIGINTs shut things down immediately
+      trap 'INT', 'DEFAULT'
+
+      server.shutdown
+   end
+
+   # Start the server here. Any code after server.start will be executed after
+   # the server shuts down.
+   logger.info "Starting web server at #{address}:#{port} (CTRL-C to stop)"
+   server.start
+
+   # Clean up the hooks, otherwise HipChat will keep trying to call us.
+   logger.info "Cleaning up webhooks"
+   remove_hipchat_webhooks hipchat, room_name, webhook_name
+end
+
+def load_settings!
+   config_file_argument = ARGV[0] ? File.absolute_path(ARGV[0]) : nil
+   config_file = config_file_argument || './hangbot.yaml'
+   default_word_list = File.expand_path(
+      File.join(File.dirname(__FILE__), '../bandnames.txt')
+   )
+
+   # Use Configliere to define and read in our settings from hangbot.yaml
+   Settings.define 'word_list',
+      description:"Word list file"
+   Settings.define 'local_server.base_url', required:true,
+      description:"URL for your local server, as you would access it from the outside world (accounting for NAT, port forwarding, etc.)"
+   Settings.define 'local_server.bind_address',
+      description:"Address for the local server to bind to"
+   Settings.define 'local_server.port',
+      description:"Port to listen on"
+   Settings.define 'hipchat.room_name', required:true,
+      description:"HipChat room to join"
+   Settings.define 'hipchat.api_token', required:true,
+      description:"OAuth bearer token. Must have admin_room and send_notification scopes for the room."
+   Settings.define 'hipchat.timeout',
+      description:"Seconds before a HipChat API request times out."
+   Settings({ # defaults
+      'word_list' => default_word_list,
+      'local_server' => {
+         'bind_address' => '0.0.0.0',
+         'port' => 4567
+      },
+      'hipchat' => {
+         'timeout' => 30
+      }
+   })
+   Settings.read config_file
+   Settings.resolve!
+
+   # The word_list's path is relative to the config file. Expand it so that we
+   # have the right path later on.
+   Settings['word_list_full_path'] =
+      File.expand_path(Settings['word_list'], File.dirname(config_file))
+end
+
+
+def partial_solution_string game 
+   game.partial_solution.map{ |char| char || '_' }.join(' ')
+end
+
+def game_status game
+   misses_list = game.incorrect_guesses.empty? ? "" : ": #{game.incorrect_guesses.to_a.join(', ')}"
+   misses_message = "[#{game.incorrect_guesses.size}/#{game.guess_limit} misses#{misses_list}]"
+
+   "#{partial_solution_string game}  #{misses_message}"
+end
+
+def main
+   # Set up a logger with the same output format as WEBrick
+   logger = Logger.new STDERR
+   logger.formatter = proc do |severity, datetime, progname, msg|
+     "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}  #{msg}\n"
+   end
+
+   load_settings!
+   webhook_url = URI.join Settings['local_server']['base_url'], '/'
+   wordlist = HangmanWordlist.new Settings['word_list_full_path']
+   game = nil
+
+   respond_to_hipchat_messages(
+      address:Settings['local_server']['bind_address'],
+      port:Settings['local_server']['port'],
+      webhook_url:webhook_url,
+      room_name:Settings['hipchat']['room_name'],
+      api_token:Settings['hipchat']['api_token'],
+      timeout:Settings['hipchat']['timeout'],
+      logger:logger
+   ) do |message|
+      # Split up a "/command [args...]" message into its parts
+      message_parts = /^\/(?<command>\w+)(\s+(?<args>.*))?$/.match message
+      if message_parts
+         command = message_parts['command']
+         args = message_parts['args']
+
+         case command
+         # New game command
+         when 'hangman'
+            game = HangmanGame.new wordlist.random_word
+            "Starting a new game. Fill in the blanks: #{partial_solution_string game}\nMake guesses with \"/guess LETTER\". #{game.remaining_misses} mistakes and you're toast."
+
+         # Command to guess a letter
+         when 'guess'
+            unless game
+               next "No game in progress. Use /hangman to start a new one."
+            end
+
+            if game.finished?
+               next "Game's over! Use /hangman to start a new one."
+            end
+
+            # See if the command included a valid guess
+            guess = args.strip.upcase
+            unless HangmanGame.acceptable_guess? guess
+               next "The /guess command takes a single letter of the alphabet."
+            end
+
+            if game.guessed? guess
+               next "#{guess} has already been guessed."
+            end
+
+            # Make the guess and let the user know how it turned out
+            game.guess! guess
+            if game.won?
+               "You got it! The answer was #{game.word}. (success)"
+            elsif game.lost?
+               "(sadpanda) Aww, you lost. The correct answer was #{game.word}."
+            else
+               # No win or loss yet -- just print out the game state.
+               game_status game
+            end
+         end
+      end
+   end
+end
+
+main

data/lib/hangman_game.rb

@@ -0,0 +1,167 @@
+require 'set'
+
+# Game logic & state. Create an instance to start a game, then use the #guess!
+# method to progress. The #won? and #lost? methods will tell when the game is
+# over, and #partial_solution shows the parts of the target word that have been
+# guessed correctly so far.
+class HangmanGame
+   attr_reader :word, :guess_limit
+
+   # Creates a new game with +word+ as the target.
+   #
+   # Raises an ArgumentError if +word+ is invalid.
+   def initialize word, guess_limit=6
+      @word = HangmanGame.guard_word(word).freeze
+
+      # Letters used in the target word. These are the letters the user needs
+      # to guess correctly to win.
+      @correct_letters = Set.new(
+         @word.chars.find_all {|char| HangmanGame.acceptable_guess? char }
+      ).freeze
+
+      @guessed_letters = Set.new
+
+      if guess_limit <= 0
+         raise ArgumentError, "guess_limit must be higher than 0"
+      end
+
+      @guess_limit = guess_limit.freeze
+   end
+
+   # Returns a Set containing all of the incorrect guesses so far.
+   def incorrect_guesses
+      @guessed_letters - @correct_letters
+   end
+
+   # Returns a Set of all the correct guesses so far.
+   def correct_guesses
+      @guessed_letters & @correct_letters
+   end
+
+   # Returns a Set of all guesses so far.
+   def guesses
+      @guessed_letters.clone
+   end
+
+   # Returns the remaining number of missed guesses before the game is lost.
+   def remaining_misses
+      @guess_limit - incorrect_guesses.size
+   end
+
+   # Returns an array representing the target word. Letters that have already
+   # been guessed are included; letters that have not yet been guessed are nil.
+   # Any other characters (spaces, dashes) are included.
+   def partial_solution
+      @word.chars.map do |letter|
+         if HangmanGame::ACCEPTABLE_LETTER =~ letter
+            # Letters of the alphabet
+            if @guessed_letters.include? letter
+               letter
+            else
+               nil
+            end
+         else
+            # Non-alpha characters
+            letter
+         end
+      end
+   end
+
+   # Guesses a letter. Returns true if the letter is in the target word, false
+   # if not.
+   #
+   # Raises HangmanGame::StateError if the game has already ended or the letter
+   # has already been guessed.
+   def guess! raw_letter
+      letter = HangmanGame.guard_guess(raw_letter)
+
+      # Make sure this guess is valid for the current game state
+      if self.finished?
+         raise HangmanGame::StateError, "guess! called after game ended"
+      end
+      if self.guessed? letter
+         raise HangmanGame::StateError, "letter already guessed: #{letter}"
+      end
+
+      @guessed_letters.add letter
+      @correct_letters.include? letter
+   end
+
+   # Returns true if the letter has already been guessed.
+   def guessed? raw_letter
+      letter = HangmanGame.guard_guess(raw_letter)
+
+      @guessed_letters.include? letter
+   end
+
+   # True if the game has been won.
+   def won?
+      !self.lost? && @guessed_letters >= @correct_letters
+   end
+
+   # True if the game has been lost.
+   def lost?
+      self.incorrect_guesses.size >= @guess_limit
+   end
+
+   # True if the game has concluded.
+   def finished?
+      self.lost? || self.won?
+   end
+
+   # Checks to see if a string constitutes a valid target word. That means any
+   # string of plain letters (A-Z), optionally separated by hyphens, spaces, and apostrophes.
+   #
+   # Note that this doesn't check any kind of dictionary. Right now we're just
+   # interested in limiting the character set.
+   def self.acceptable_word? word
+       HangmanGame::ACCEPTABLE_WORD =~ HangmanGame.normalize(word)
+   end
+
+   def self.acceptable_guess? letter
+      HangmanGame::ACCEPTABLE_LETTER =~ HangmanGame.normalize(letter)
+   end
+
+   # Readable dump of the game state for debugging and that sort of thing
+   def dump
+      word_with_blanks = self.partial_solution.map{ |c| c || '_' }.join('')
+      <<-END
+      target word: #{@word}
+          guessed: #{word_with_blanks}
+        incorrect: [#{self.incorrect_guesses.to_a.join ', '}]
+      END
+   end
+
+   # Indicates that something was done at the wrong time in the game, like
+   # guessing a letter after winning.
+   class StateError < StandardError; end
+
+private
+
+   ACCEPTABLE_LETTER = /^[A-Z]$/
+   ACCEPTABLE_WORD = /^[A-Z]([- ']?[A-Z])*$/
+
+   def self.normalize word_or_letter
+      word_or_letter.strip.upcase
+   end
+
+   def self.guard_guess raw_letter
+      letter = HangmanGame.normalize raw_letter
+
+      unless HangmanGame.acceptable_guess? letter
+         raise ArgumentError, "Invalid guess: \"#{letter}\" (only plain letters allowed)"
+      end
+
+      letter
+   end
+
+   def self.guard_word raw_word
+      word = HangmanGame.normalize raw_word
+
+      unless HangmanGame.acceptable_word? word
+         raise ArgumentError, "Invalid word: \"#{word}\" (only plain letters A-Z separated by spaces and hyphens allowed)"
+      end
+
+      word
+   end
+end

data/lib/hangman_wordlist.rb

@@ -0,0 +1,36 @@
+require 'set'
+require 'hangman_game'
+
+# List of hangman words loaded from a text file (one word per line.)
+class HangmanWordlist
+   attr_reader :words
+
+   # Creates a word list from the given file. The file should have one word per
+   # line, and all of the words must pass HangmanGame.acceptable_word?. Those
+   # that don't pass will be left out.
+   def initialize file
+      word_set = Set.new
+
+      File.open(file, "r") do |f|
+         f.each_line do |raw_line|
+            line = raw_line.strip.upcase
+
+            if HangmanGame.acceptable_word? line
+               word_set.add line
+            end
+         end
+      end
+
+      @words = word_set.to_a.freeze
+
+      Random.srand
+   end
+
+   def size
+      @words.size
+   end
+
+   def random_word
+      @words[Random.rand(self.size)]
+   end
+end

data/lib/hipchat_party.rb

@@ -0,0 +1,76 @@
+require 'httparty'
+require 'json'
+
+
+# Thin abstraction layer for the HipChat v2 API.
+#
+# The official API's module name is "hipchat", hence the disambiguating "party" suffix.
+#
+# TODO: error handling for requests
+class HipChatParty
+   include HTTParty
+   base_uri 'https://api.hipchat.com/v2/'
+   headers 'Content-Type' => "application/json"
+   format :json
+
+   # +api_token+ must have admin_room and send_notification scopes.
+   #
+   # +timeout+ is specified in seconds.
+   def initialize api_token, timeout:30
+      self.class.headers 'Authorization' => "Bearer #{api_token.strip}"
+   end
+
+   # Delete all webhooks with the specified name in a room
+   def delete_webhooks_by_name room_name, hook_name
+      # We can't delete webhooks by name; we have to use IDs. First we look up
+      # the IDs, then we use them to delete the hooks.
+      webhooks_response = self.get_webhooks room_name
+      webhooks = webhooks_response.parsed_response['items']
+      webhooks_to_delete = webhooks.find_all { |wh| wh['name'] == hook_name }
+      webhooks_to_delete.each do |webhook|
+         self.delete_webhook_by_id room_name, webhook['id']
+      end
+   end
+
+   # https://www.hipchat.com/docs/apiv2/method/delete_webhook
+   def delete_webhook_by_id room_name, hook_id
+      self.class.delete "/room/#{room_name}/webhook/#{hook_id}"
+   end
+
+   # List all webhooks for the room
+   #
+   # https://www.hipchat.com/docs/apiv2/method/get_all_webhooks
+   def get_webhooks room_name
+      self.class.get "/room/#{room_name}/webhook"
+   end
+
+   # Sets a webhook to call back to +url+ whenever +event+ occurs in
+   # +room_name+. If +pattern+ is set, and the event type is "room_message",
+   # only matching messages will trigger a callback.
+   #
+   # https://www.hipchat.com/docs/apiv2/method/create_webhook
+   def create_webhook room_name, hook_name, event, url, pattern:nil
+      post_body = {
+         url: url,
+         event: event,
+         name: hook_name
+      }
+
+      if event == 'room_message' && pattern
+         post_body['pattern'] = pattern
+      end
+
+      response = self.class.post "/room/#{room_name}/webhook", body: post_body.to_json
+      response.parsed_response['id']
+   end
+
+   # https://www.hipchat.com/docs/apiv2/method/send_room_notification
+   def send_room_notification room_name, message, color:'yellow', notify:false, format:'text'
+      self.class.post "/room/#{room_name}/notification", body: {
+         color: color,
+         message: message,
+         notify: notify,
+         message_format: format
+      }.to_json
+   end
+end

data/spec/hangman_game_spec.rb

@@ -0,0 +1,78 @@
+require 'minitest/autorun'
+require 'hangman_game'
+
+describe HangmanGame do
+   before do
+      @game = HangmanGame.new('pinkerton', 3)
+   end
+
+   describe "when initialized" do
+      it "must reject invalid words" do
+         ['', '   ', '- -', 'af2', 'wnmkl.df'].each do |word|
+            proc { HangmanGame.new(word) }.must_raise ArgumentError
+         end
+      end
+
+      it "must accept valid words" do
+         ['toothless', ' turtle\'s ', 'tor-pe-do', 'torte truck'].each do |word|
+            HangmanGame.new(word).wont_be_nil
+         end
+      end
+
+      it "must allow at least one guess" do
+         proc { HangmanGame.new('foo', 0) }.must_raise ArgumentError
+      end
+   end
+
+   describe "when a player guesses" do
+      it "must detect correct guesses" do
+         @game.guess! 'p'
+         @game.correct_guesses.must_include 'P'
+         @game.guess! 'o'
+         @game.correct_guesses.must_include 'O'
+         @game.incorrect_guesses.must_be_empty
+      end
+
+      it "must detect incorrect guesses" do
+         @game.guess! 'z'
+         @game.incorrect_guesses.must_include 'Z'
+         @game.correct_guesses.must_be_empty
+         @game.remaining_misses.must_equal 2
+      end
+
+      it "must detect a win" do
+         'plinkerdto'.each_char{ |c| @game.guess! c }
+
+         assert @game.won?
+         assert @game.finished?
+         assert !@game.lost?
+      end
+
+      it "must detect a loss" do
+         'plinkerdtu'.each_char{ |c| @game.guess! c }
+
+         assert !@game.won?
+         assert @game.finished?
+         assert @game.lost?
+      end
+
+      it "must complain if the game's already ended" do
+         proc {
+            'plinkerdtug'.each_char{ |c| @game.guess! c }
+         }.must_raise HangmanGame::StateError
+      end
+
+      it "must reject invalid guesses" do
+         ['', '-', '  ', 'fw'].each do |guess|
+            proc { @game.guess! guess }.must_raise ArgumentError
+         end
+      end
+
+      it "must reject duplicate guesses" do
+         proc {
+            @game.guess! 'z'
+            @game.guess! 'Z'
+         }.must_raise HangmanGame::StateError
+      end
+   end
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: hangbot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Josh Strater
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: configliere
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: Small Hangman game for HipChat. Uses the v2 API and webhooks.
+email:
+- jstrater@gmail.com
+executables:
+- hangbot
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bandnames.txt
+- bin/hangbot
+- example.hangbot.yaml
+- hangbot.gemspec
+- lib/hangbot.rb
+- lib/hangman_game.rb
+- lib/hangman_wordlist.rb
+- lib/hipchat_party.rb
+- spec/hangman_game_spec.rb
+homepage: https://github.com/jstrater/hangbot
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Hangman for HipChat
+test_files:
+- spec/hangman_game_spec.rb