dickburt 0.0.5

data/.gitignore

@@ -0,0 +1,2 @@
+script/
+pkg/

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2@dickburt --create

data/Gemfile

@@ -0,0 +1,18 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in camper_van.gemspec
+gemspec
+
+# specified here rather than in gemspec because they're
+# for local mac development only
+group :development do
+  gem "rb-fsevent"
+  gem "growl"
+  gem "guard"
+  # 0.4.0.rc versions are still git-only
+  gem "guard-minitest", :git => "https://github.com/guard/guard-minitest.git"
+  gem "fabrication"
+  gem "ffaker", :require => "ffaker"
+  gem 'vcr'
+  gem "fakeweb"
+end

data/Gemfile.lock

@@ -0,0 +1,63 @@
+GIT
+  remote: https://github.com/guard/guard-minitest.git
+  revision: a5479b18222ba4f95e65d558484d6c32456ca401
+  specs:
+    guard-minitest (0.4.0)
+      guard (~> 0.4)
+
+PATH
+  remote: .
+  specs:
+    dickburt (0.0.5)
+      addressable (~> 2.2.6)
+      eventmachine (~> 0.12.10)
+      json (~> 1.5.1)
+      logging (~> 1.5.1)
+      map (~> 4.3.0)
+      patron (~> 0.4.11)
+      trollop (~> 1.16.2)
+      twitter-stream (~> 0.1.14)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.6)
+    eventmachine (0.12.10)
+    fabrication (1.0.1)
+    fakeweb (1.3.0)
+    ffaker (1.8.0)
+    growl (1.0.3)
+    guard (0.6.2)
+      thor (~> 0.14.6)
+    http_parser.rb (0.5.1)
+    json (1.5.3)
+    little-plugger (1.1.2)
+    logging (1.5.2)
+      little-plugger (>= 1.1.2)
+    map (4.3.0)
+    minitest (2.2.2)
+    patron (0.4.14)
+    rb-fsevent (0.4.3.1)
+    simple_oauth (0.1.5)
+    thor (0.14.6)
+    trollop (1.16.2)
+    twitter-stream (0.1.14)
+      eventmachine (>= 0.12.8)
+      http_parser.rb (~> 0.5.1)
+      simple_oauth (~> 0.1.4)
+    vcr (1.11.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dickburt!
+  fabrication
+  fakeweb
+  ffaker
+  growl
+  guard
+  guard-minitest!
+  minitest (~> 2.2.2)
+  rb-fsevent
+  vcr

data/Guardfile

@@ -0,0 +1,7 @@
+guard 'minitest' do
+  # with Minitest::Spec
+  watch(%r|^spec/(.*)_spec\.rb|)
+  watch(%r|^spec/fabricators/(.*)_fabricator\.rb|) { |m| "spec/dickburt/#{m[1]}_spec.rb" }
+  watch(%r|^lib/(.*)\.rb|)             { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r|^spec/spec_helper\.rb|)     { "spec" }
+end

data/README.md

@@ -0,0 +1,50 @@
+Dickburt: A campfire bot
+========================
+  
+    gem install dickburt
+    
+    dickburt desertbeaver the_overlook --token the_token_for_your_bot_user
+
+Connecting to Campfire™
+-----------------------
+Dickburt runs from the command line, he gets installed when the gem gets installed. Connecting him to your campfire requires a few things.
+
+First, you need a user for your bot. Go make a user, you'll need an email for your bot, but I'll assume you know how to make an email and signup for campfire. Once you've signed up and signed in as your bot, you're going to need to find the API token. Click "My info" and the [API token is pretty easy to spot](http://cl.ly/3W0r1H1h3a281z1a1C00 "Spotting the api token").
+
+Second, the command line args are:
+
+1. The subdomain of the campfire you want to join, so, in the example above we're trying to join http://desertbeaver.campfirenow.com
+
+2. The campfire room we want to join, downcased and spaces replaced with underscores. So again in the above example the_overlook is means we'll join The Overlook room. Pretty easy. 
+
+3. The last argument is the API token. Dickburt will store the api token in ~/.dickburt/config.yml after the first time you give him a token for a subdomain. Note! API Tokens are unique by subdomain. 
+  
+Commands
+--------
+Right now, this sucks, but you have to say "dickburt <somecommand>" or "somecommand blah lbah blah dickburt". You just have to say a command and dickburt in the same message. 
+  
+His commands are really limited but it is easy to make new ones.
+  
+  - hi
+  - imageme (takes a query)
+  - beerme
+  - whatup
+  - fuckyeah
+  
+Examples
+--------
+
+    Tyler: dickburt imageme hipster ferrets
+    # => will upload the first image it finds for "hipster ferrets" on google image search
+    
+    Tyler: dickburt whatup
+    # => dickburt: whatup Tyler
+    
+TODO
+----
+* Use a better http library like faraday. Patron sucks. 
+* Use yajl to parse json stream.
+* Make dickburt helpful. Like if he doesn't know a command he should tell you and probably also tell you what he does know.
+* Keep a list of Dickburt::Users around
+* Lookup everyone in the Room when we connect
+* Lookup the user that messaged dickburt from our list of Users, or, go get the info for the user and store them in the list.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = %w(lib spec)
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :test

data/bin/dickburt

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require "trollop"
+$:.unshift File.expand_path('../../lib/', __FILE__)
+require "dickburt"
+
+t = Trollop::Parser.new do 
+  opt :token, "The campfire token for dickburt",  :type => :string
+end 
+
+opts = Trollop::with_standard_exception_handling( t ) do
+  opts = t.parse ARGV
+  host = t.leftovers.shift
+  room = t.leftovers.shift
+  unless host && room
+    raise Trollop::CommandlineError, "host and room must be provided as arguments. Ex: dickburt subdomain_of_my_campfire super_awesome_room" 
+  end
+  
+  begin
+    Dickburt::Config.set_token(host.to_sym, opts[:token])
+    config = Dickburt::Config.config_hash(host, room)
+    Dickburt::Server.run(config)
+  rescue ::StandardError => se
+    raise Trollop::CommandlineError, se.message
+  end
+end

data/dickburt.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dickburt/version"
+Gem::Specification.new do |s|
+  s.name        = "dickburt"
+  s.version     = Dickburt::VERSION
+  s.authors     = ["Tyler Montgomery"]
+  s.email       = ["tyler@everlater.com"]
+  s.homepage    = "http://github.com/ubermajestix/dickburt"
+  s.summary     = %q{Campfire bot}
+  s.description = %q{Dickburt finds pugs}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "eventmachine"       , "~> 0.12.10"
+  s.add_dependency "patron"             , "~> 0.4.11"
+  s.add_dependency "logging"            , "~> 1.5.1"
+  s.add_dependency "trollop"            , "~> 1.16.2"
+  s.add_dependency 'twitter-stream'     , "~> 0.1.14"
+  s.add_dependency 'json'               , "~> 1.5.1"
+  s.add_dependency "addressable"        , "~> 2.2.6"
+  s.add_dependency 'map'                , "~> 4.3.0"
+
+  s.add_development_dependency "minitest", "~> 2.2.2"
+end

data/lib/dickburt.rb

@@ -0,0 +1,29 @@
+require 'dickburt/version'
+require 'twitter/json_stream'
+require 'patron'
+require 'json'
+require "addressable/uri"
+require 'map'
+require 'logging'
+require 'fileutils'
+
+module Dickburt
+  require 'dickburt/bot'
+  require 'dickburt/campfire'
+  require 'dickburt/config'
+  require 'dickburt/logger'
+  require 'dickburt/message'
+  require 'dickburt/response'
+  require 'dickburt/retryable'
+  require 'dickburt/room'
+  require 'dickburt/server'
+  require 'dickburt/user'
+  class Error < StandardError; end;
+  def self.logger
+    @logger = Logging::Logger[self.name]
+  end
+  
+end
+
+
+

data/lib/dickburt/bot.rb

@@ -0,0 +1,137 @@
+class Dickburt::Bot
+  attr_accessor :message
+  attr_accessor :user
+  attr_accessor :room
+  def initialize(message, user, room)
+    @message = message
+    @user = user
+    @room = room
+  end
+  
+  def self.used_images
+    @used_images ||= {}
+  end
+  
+  def self.image_page
+    @image_page ||= {}
+  end
+    
+   def self.process(message, room, campfire)
+    if message[:type] == 'TextMessage' && message.body.match(/\bdickburt\b/i)
+      dickburt = Dickburt::Bot.new(message, room.find_user(message.user_id), room)
+      command  = dickburt.parse_command
+      args     = dickburt.parse_args
+      if command
+        response = args ? dickburt.send(command, args) : dickburt.send(command)
+        room.speak(response)
+      end
+    end
+  end
+  
+  def commands
+    @commands ||= %w(imageme beerme hi fuckyeah)
+  end
+  
+  def commands_regex
+    Regexp.union(commands.map{|c| /\b#{c}\b/})
+  end
+  
+  def parse_command
+    command = commands.detect{|c| message.body.downcase.match(/\b#{c}\b/)}
+    command = 'whatup' if message[:type] == 'EnterMessage'
+    command
+  end
+  
+  def parse_args
+    reg = Regexp.union(/dickburt:?/, commands_regex)
+    args = message.body.downcase.gsub(reg,'').strip
+    args.empty? ? nil : args
+  end
+  
+  def whatup
+    Dickburt::Response.new("whatup #{user.name}", 'Text')
+  end
+  
+  def fuckyeah
+    Dickburt::Response.new('FUCKYEAH BUDDIE!', 'Text')
+  end
+  
+  def imageme(query='funny pugs')
+    image = google_image(query)
+    if image
+      Dickburt::Response.new(image, 'Upload') 
+    else
+      Dickburt::Response.new("couldn't find any pics of #{query}", 'Text') 
+    end
+  end
+  
+  def beerme
+    Dickburt::Response.new('http://f.cl.ly/items/333i290f1x2N330u303N/beerme.png', 'Upload')
+  end
+  
+  def hi
+    whatup if rand(5) == 4
+    fuckyeah if rand(10) == 4
+    Dickburt::Response.new("Hi #{user.name}", 'Text')
+  end
+  
+  def google_image(query='funny pugs', page=0)
+    @search_server ||= Patron::Session.new
+    @search_server.base_url = "https://ajax.googleapis.com/ajax/services/search"
+    Dickburt::Bot.used_images[query] ||= []
+    page = Dickburt::Bot.image_page[query].to_i + 1 if Dickburt::Bot.image_page[query].to_i > page
+    Dickburt::Bot.image_page[query] = page
+    uri = Addressable::URI.new
+    uri.query_values = {:v => "1.0", :q => query, :rsz=>'8', :start=>page.to_s}
+    puts "finding #{query} on page #{page}"
+    response = @search_server.get("/images?#{uri.query}")
+    if response.status < 400
+      body = JSON.parse(response.body)
+      if body["responseData"]
+        results = JSON.parse(response.body)["responseData"]["results"] 
+        results.each_with_index do |image, i|
+          image = Map.new(image)
+          # check to see if we've seen this image for this query
+          next if Dickburt::Bot.used_images[query].include?(image.imageId)
+          Dickburt::Bot.used_images[query] << image.imageId
+          # check to make sure the image doesn't 404
+          exists = image_exists?(image.url)
+          next if exists == false
+          # return the image
+          @image_url = image.url
+          break # cause we found an image
+        end
+      else
+        @error= true
+      end
+    else
+      @error = true
+      puts "="*45
+      puts response.status
+      puts response.body.inspect
+      puts "="*45
+    end
+    puts @image_url.inspect
+    puts @error.inspect
+    # Keep going to the next page of results unless we got an image or blowzed up.
+    google_image(query, page+=1) unless @image_url or @error
+    @image_url
+  end
+  
+  def image_exists?(url)
+    begin
+      image = Patron::Session.new
+      split_url = url.split("/",4)
+      image_url = split_url.pop
+      image.base_url = split_url.join("/")
+      response = image.head("/#{image_url}")
+      response.status < 400
+    rescue Patron::ConnectionFailed, Patron::ConnectionFailed
+      puts "="*45
+      puts "DNE!"
+      puts "="*45
+      false
+    end
+  end
+    
+end

data/lib/dickburt/campfire.rb

@@ -0,0 +1,38 @@
+class Dickburt::Campfire
+  attr_accessor :token
+  attr_accessor :host
+  
+  class Error < StandardError; end;
+  
+  def initialize(args={})
+    @token = args[:token] 
+    @host = "https://#{args[:host]}.campfirenow.com"
+  end
+  
+  def http
+    @http ||= Patron::Session.new
+    @http.base_url = host
+    @http.headers["Content-Type"] = "application/json"
+    @http.headers['User-Agent'] = "Dickburt #{Dickburt::VERSION}"
+    @http.username = token 
+    @http.password = "x"
+    @http.connect_timeout = 6000
+    @http.timeout = 6000
+    @http
+  end
+  
+  def rooms
+    return @rooms if @rooms
+    response = http.get("/rooms.json")
+    @rooms = []
+    if response.status < 400
+      @rooms = JSON.parse(response.body)['rooms'] 
+      @rooms.collect! do |room|
+        Dickburt::Room.new(room, self)
+      end
+    else
+      raise Dickburt::Campfire::Error, response.status.to_s + ": " + response.body
+    end
+  end
+  
+end

data/lib/dickburt/config.rb

@@ -0,0 +1,63 @@
+# Store the campfire api token b/c I'm sick of looking that shit up.
+# I know the host and room I want to access, but not the token, so if the token
+# is provided, store it - tokens are uniq by host - so store it per host.
+# Provides a nice config hash that we build up from the command line to hand off to Dickburt::Server.
+
+module Dickburt
+  module Config
+
+    class << self
+      
+      # Provides a nice config hash that we build up from the command line to hand off to Dickburt::Server.
+      # This is only ever called bin/dickburt. That script raises errors for missing host and room, so its
+      # a bit redundant redundant to check that here.
+      def config_hash(host, room)
+        token = config[host.to_sym][:token] if config[host.to_sym]
+        unless token
+          raise Dickburt::Error, "You need to provide an api token.\n Just add: --token yourtokenfromcampfire to the command line args.\n The token will get stored in ~/.dickburt/config.yml for next time so you don't have to remember it"
+        end
+        { host:   host, 
+          token:  token, 
+          room:   room.downcase.gsub(/\s/,'_') }
+      end
+      
+      # Public: Stores the given token for the given host.
+      # Will not raise an error if the token is not given, leaves that up to bin/dickburt.
+      def set_token(host, token=nil)
+        if token
+          config[host.to_sym] = {:token => token}
+          write
+        end
+      end
+      
+      # Reads the config, or gives you an empty hash.
+      def config
+        ensure_config_exists
+        @config ||= (YAML.load_file(config_file) || {})
+      end
+      
+    private
+      
+      # Make sure the config dir and config file are on disk.
+      def ensure_config_exists
+        FileUtils.mkdir(config_dir)  unless Dir.exists?(config_dir)
+        FileUtils.touch(config_file) unless File.exists?(config_file)
+      end
+      
+      def config_file
+        "#{config_dir}/config.yml"
+      end
+      
+      def config_dir
+        "#{Dir.home}/.dickburt"
+      end
+      
+      # Writes the @config as yaml to disk.
+      def write
+        ensure_config_exists
+        File.open(config_file, "wb"){|f| f.write @config.to_yaml}
+      end
+      
+    end
+  end
+end

data/lib/dickburt/logger.rb

@@ -0,0 +1,7 @@
+module Dickburt
+  module Logger
+    def logger
+      Dickburt.logger
+    end
+  end
+end

data/lib/dickburt/message.rb

@@ -0,0 +1,25 @@
+class Dickburt::Message < Map
+  
+  attr_accessor :command
+  attr_accessor :args
+  
+  def initialize(json)
+    super(JSON.parse(json))
+    puts self.inspect
+    puts "="*45
+    self
+  end
+  
+  def process_command
+    return unless @command
+    # TODO make dickburt aware of users so he can respond to them.
+    # I really don't like this setup of not having instances of the bot.
+    # If i got an instance I could save things to it, like the user and message object
+    # Then it wouldn't be as weird to process the command here on the message object
+    @args ? Dickburt::Bot.send(@command, @args) : Dickburt::Bot.send(@command)
+  end
+  
+  def user
+    
+  end
+end

data/lib/dickburt/response.rb

@@ -0,0 +1,17 @@
+class Dickburt::Response
+  attr_accessor :message_type
+  attr_accessor :body
+  
+  def initialize(body, message_type)
+    @message_type = message_type
+    @body = body
+  end
+  
+  def to_campfire_hash
+    {:message => {:body => @body, :type => @message_type + "Message"}}
+  end
+  
+  def to_json
+    self.to_campfire_hash.to_json
+  end
+end

data/lib/dickburt/retryable.rb

@@ -0,0 +1,30 @@
+module Dickburt
+  module Retryable
+    # Options:
+    # * :tries - Number of retries to perform. Defaults to 1.
+    # * :on - The Exception on which a retry will be performed. Defaults to Exception, which retries on any Exception.
+    #
+    # Example
+    # =======
+    #   retryable(:tries => 1, :on => OpenURI::HTTPError) do
+    #     # your code here
+    #   end
+    #
+    def retryable(options = {}, &block)
+      opts = { :tries => 1, :on => Exception }.merge(options)
+
+      retry_exception, retries = opts[:on], opts[:tries]
+
+      begin
+        return yield
+      rescue retry_exception
+        puts "="*45
+        puts "#{retry_exception} raised. Retrying #{retries - 1} more times"
+        puts "="*45
+        retry if (retries -= 1) > 0
+      end
+
+      yield
+    end
+  end
+end

data/lib/dickburt/room.rb

@@ -0,0 +1,64 @@
+module Dickburt
+  class Room < Map
+    attr_accessor :campfire
+    attr_accessor :response
+    include Logger
+    def initialize(room, campfire)
+      super(room)
+      @campfire = campfire
+    end
+  
+    def response=(response)
+      puts "="*45
+      puts response.status
+      puts "="*45
+      if response.status >= 400 
+        logger.error JSON.parse(speak.body).inspect
+      end
+    end
+  
+    def speak(response)
+      response = @campfire.http.post("/room/#{id}/speak.json", response.to_json)
+    end
+  
+    def join
+      response = @campfire.http.post("/room/#{id}/join.json", {})
+    end
+    
+    def leave
+      response = @campfire.http.post("/room/#{id}/leave.json", {})
+    end
+  
+    def stream
+      Twitter::JSONStream.connect(
+        :path => "/room/#{id}/live.json",
+        :host => 'streaming.campfirenow.com',
+        :auth => "#{campfire.token}:x"
+      )
+    end
+    
+    # Returns an Array of current users for the room.
+    def users
+      response = @campfire.http.get("/room/#{id}.json")
+      room = Map.new(JSON.parse(response.body)["room"])
+      room.users
+    end
+    
+    # Looks up the user by user_id for the current users in the room
+    #
+    #  user_id - String 37signals user id
+    #
+    # Returns a Dickburt::User if it finds that user in the room
+    # Raises an error if they can't be found.
+    def find_user(user_id)
+      user = users.detect{|u| u.id == user_id}
+      raise Dickburt::Error, "user #{user_id} not found" unless user
+      User.new(user.to_json, campfire)
+    end
+    
+    def handle_failure
+    
+    end
+  
+  end
+end

data/lib/dickburt/server.rb

@@ -0,0 +1,46 @@
+module Dickburt
+  module Server
+    class << self
+      include Logger
+      include Retryable
+    end
+    def self.run(args={})
+      logger.info "boom!"
+      EventMachine::run do
+        retryable(:tries => 5, :on => Patron::TimeoutError) do
+          @campfire = Dickburt::Campfire.new(args)
+          puts "="*45
+          puts "Connected to #{@campfire.host} with token #{@campfire.token}"
+          puts "="*45
+          @room = @campfire.rooms.detect{|r| r.name.downcase.gsub(/\s/,'_') == args[:room].downcase.gsub(/\s/,'_')}
+          raise Dickburt::Error, "Could not find a campfire room that matches \"#{args[:room]}\"" unless @room
+          @room.join
+          puts "Ready for messages..."
+          puts "="*45
+        end
+        stream = @room.stream
+ 
+        stream.each_item do |item|
+          message = Dickburt::Message.new(item)
+          puts message.inspect
+          Dickburt::Bot.process(message, @room, @campfire)
+        end
+ 
+        stream.on_error do |message|
+          puts "ERROR: #{message.inspect}"
+        end
+ 
+        stream.on_max_reconnects do |timeout, retries|
+          puts "Tried #{retries} times to connect."
+          exit
+        end
+  
+        trap("INT") do 
+          @room.leave if @room
+          EM.stop
+        end  
+  
+      end
+    end
+  end
+end

data/lib/dickburt/user.rb

@@ -0,0 +1,10 @@
+module Dickburt
+  class User < Map
+    attr_accessor :campfire
+    include Logger
+    def initialize(json, campfire)
+      super(JSON.parse(json))
+      @campfire = campfire
+    end
+  end
+end

data/lib/dickburt/version.rb

@@ -0,0 +1,3 @@
+module Dickburt
+  VERSION = "0.0.5"
+end

data/spec/dickburt/bot_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Dickburt::Bot do
+  
+  before(:each) do
+    @message = Dickburt::Message.new({type: "TextMessage", body: "dickburt beerme"}.to_json)
+    @user = Dickburt::User.new({name: "Human"}.to_json, campfire )
+    @room = Dickburt::Room.new({name: 'Campfire Room'}, campfire)
+    @dickburt = Dickburt::Bot.new(@message, @user, @room)
+  end
+  
+  it "must deliver beer" do
+    @dickburt.must_respond_to :beerme
+    @dickburt.beerme.must_be_kind_of Dickburt::Response
+  end
+  
+  it "must deliver images" do
+    skip "use vcr to mock web response"
+    @dickburt.must_respond_to :imageme
+    @dickburt.imageme.must_be_kind_of Dickburt::Response
+  end
+  
+  context ".parse_args" do
+    it "must parse arguments from a message" do
+      message = Dickburt::Message.new({type: "TextMessage", body: "dickburt imageme funny hipsters"}.to_json)
+      dickburt = Dickburt::Bot.new(message, @user, @room)
+      dickburt.parse_args.must_equal 'funny hipsters'
+      
+    end
+  
+    it "must return nil if no args exist" do
+      message = Dickburt::Message.new({type: "TextMessage", body: "dickburt imageme"}.to_json)
+      dickburt = Dickburt::Bot.new(message, @user, @room)
+      dickburt.parse_args.must_be_nil
+    end    
+  end
+  
+  context 'imageme' do
+  end
+  
+end

data/spec/dickburt/campfire_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Dickburt::Campfire do
+  it "should take the subdomain as the host and format it" do
+    c = Dickburt::Campfire.new(:host=>"everlater")
+    c.host.must_equal "https://everlater.campfirenow.com"
+  end
+end

data/spec/dickburt/config_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Dickburt::Config do
+  
+  before(:each) do
+    FileUtils.rm_rf("#{Dir.home}/.dickburt/config.yml", :noop=>true) 
+  end
+  
+  it "should create the ~/.dickburt dir" do
+  end
+  
+  it "should write the config when we add a token" do
+    Dickburt::Config.set_token("shabam", 'boooooom')
+    Dir.exists?("#{Dir.home}/.dickburt").must_equal true
+    File.exists?("#{Dir.home}/.dickburt/config.yml").must_equal true
+    Dickburt::Config.config.keys.must_include :shabam
+    Dickburt::Config.config[:shabam].must_equal ({:token => "boooooom"})
+  end
+  
+  it "should read config" do
+    Dickburt::Config.config.must_be_kind_of Hash
+  end
+  
+end

data/spec/dickburt/response_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+describe Dickburt::Response do
+  before :each do
+    @response = Dickburt::Response.new("beer", "Text")
+  end
+  
+  it "should give me a hash for campfire" do
+    @response.to_campfire_hash.must_be_kind_of Hash
+    @response.to_campfire_hash.keys.must_include :message
+  end
+  
+  it "should respond to to_json with the appropriate hash" do
+    JSON.parse(@response.to_json).keys.must_include "message"
+  end
+end

data/spec/dickburt/room_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Dickburt::Room do
+  context "handling failure" do
+    before :each do
+      @response = Map.new(:status => 401, :body => "you fucked up")
+      @room = Dickburt::Room.new({name: 'Campfire Room'}, campfire)
+    end
+
+    it "handles failure if the response is bad" do
+      skip
+      @room.response = @response
+    end
+  end
+end

data/spec/dickburt/server_spec.rb

@@ -0,0 +1,8 @@
+require "spec_helper"
+
+describe Dickburt::Server do
+  it "has a run module method" do
+    Dickburt::Server.must_respond_to :run
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require "bundler"
+
+Bundler.setup :default, :development
+
+require "minitest/spec"
+require "minitest/autorun"
+require "minitest/mock"
+
+require 'fabrication'
+require 'ffaker'
+
+require "dickburt"
+
+alias :context :describe
+
+def user_mock
+  mock = MiniTest::Mock.new
+  mock.expect("name", "Human")
+end
+
+def campfire
+  @campfire ||= Dickburt::Campfire.new(:host=>"everlater")
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: dickburt
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+  prerelease: 
+platform: ruby
+authors:
+- Tyler Montgomery
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-06 00:00:00.000000000 -06:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &2164638520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *2164638520
+- !ruby/object:Gem::Dependency
+  name: patron
+  requirement: &2164638020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.11
+  type: :runtime
+  prerelease: false
+  version_requirements: *2164638020
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: &2164637560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *2164637560
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: &2164637100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.16.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *2164637100
+- !ruby/object:Gem::Dependency
+  name: twitter-stream
+  requirement: &2164636640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.14
+  type: :runtime
+  prerelease: false
+  version_requirements: *2164636640
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &2164636180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *2164636180
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: &2164635720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *2164635720
+- !ruby/object:Gem::Dependency
+  name: map
+  requirement: &2164562540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2164562540
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2164562080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+  type: :development
+  prerelease: false
+  version_requirements: *2164562080
+description: Dickburt finds pugs
+email:
+- tyler@everlater.com
+executables:
+- dickburt
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- README.md
+- Rakefile
+- bin/dickburt
+- dickburt.gemspec
+- lib/dickburt.rb
+- lib/dickburt/bot.rb
+- lib/dickburt/campfire.rb
+- lib/dickburt/config.rb
+- lib/dickburt/logger.rb
+- lib/dickburt/message.rb
+- lib/dickburt/response.rb
+- lib/dickburt/retryable.rb
+- lib/dickburt/room.rb
+- lib/dickburt/server.rb
+- lib/dickburt/user.rb
+- lib/dickburt/version.rb
+- spec/dickburt/bot_spec.rb
+- spec/dickburt/campfire_spec.rb
+- spec/dickburt/config_spec.rb
+- spec/dickburt/response_spec.rb
+- spec/dickburt/room_spec.rb
+- spec/dickburt/server_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/ubermajestix/dickburt
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Campfire bot
+test_files:
+- spec/dickburt/bot_spec.rb
+- spec/dickburt/campfire_spec.rb
+- spec/dickburt/config_spec.rb
+- spec/dickburt/response_spec.rb
+- spec/dickburt/room_spec.rb
+- spec/dickburt/server_spec.rb
+- spec/spec_helper.rb