wesabot 1.0.1

data/lib/campfire/polling_bot/plugins/twitter_search/twitter_search_plugin.rb

@@ -0,0 +1,58 @@
+require 'httparty'
+
+# plugin to search twitter
+class TwitterSearchPlugin < Campfire::PollingBot::Plugin
+  priority 1
+  accepts :text_message, :addressed_to_me => true
+
+  def process(message)
+    searched = false
+
+    case message.command
+    when /(?:(?:what(?:'s)? (?:(?:are )?people|(?:is |does )?every(?:one|body)) (?:saying|tweeting|think) about)|what's the word on)\s+(?:the )?(.*?)[.?!]?\s*$/i
+      subject = $1
+      tweets = search_twitter(subject)
+      if tweets.any?
+        tweets.each {|t| bot.tweet(t) }
+      else
+        bot.say("Couldn't find anything for \"#{subject}\"")
+      end
+      return HALT
+    end
+  end
+
+  # return array of available commands and descriptions
+  def help
+    [
+      ["what are (people|is everyone) saying about <subject>", "search twitter for tweets on <subject>"],
+      ["what's the word on <subject>", "search twitter for tweets on <subject>"],
+    ]
+  end
+
+private
+
+  # construct a twitter url from the given response json
+  def twitter_url(json)
+    "http://twitter.com/#{json['from_user']}/status/#{json['id']}"
+  end
+
+  def search_twitter(subject)
+    tweets = []
+    res = HTTParty.get(
+      "http://search.twitter.com/search.json",
+      :query => { :q => subject, :result_type => "mixed" },
+      # other possible result types include "popular" and "recent"
+      :headers => {'User-Agent' => 'wesabot/1.0 github-hackarts-wesabot'})
+    case res.code
+    when 200
+      tweets = res["results"].first(5).map {|r| twitter_url(r) }
+    when 400, 420
+      bot.say("Sorry, we've hit the Twitter rate limit for searches.")
+    else
+      bot.say("Hmm...didn't work. Got this response:")
+      bot.paste("#{res.code} (#{res.message})\n#{res.body}")
+    end
+
+    return tweets
+  end
+end

data/lib/campfire/polling_bot.rb

@@ -0,0 +1,125 @@
+# PollingBot - a bot that polls the room for messages
+require 'campfire/bot'
+require 'campfire/message'
+
+require 'firering'
+
+module Campfire
+  class PollingBot < Bot
+    require 'campfire/polling_bot/plugin'
+    attr_accessor :plugins
+    HEARTBEAT_INTERVAL = 3 # seconds
+
+    def initialize(config)
+      # load plugin queue, sorting by priority
+      super
+      self.plugins = Plugin.load_all(self)
+    end
+
+    # main event loop
+    def run
+      # set up a heartbeat thread for plugins that want them
+      Thread.new do
+        loop do
+          plugins.each {|p| p.heartbeat if p.respond_to?(:heartbeat)}
+          sleep HEARTBEAT_INTERVAL
+        end
+      end
+
+      host = "https://#{config.subdomain}.campfirenow.com"
+      conn = Firering::Connection.new(host) do |c|
+        c.token = config.api_token
+        c.logger = logger
+        c.retry_delay = 2
+      end
+
+      EM.run do
+        conn.room(room.id) do |room|
+          room.stream do |data|
+
+            begin
+              klass = Campfire.const_get(data.type)
+              message = klass.new(data)
+
+              if data.from_user?
+                data.user do |user|
+                  dbuser = User.first(:campfire_id => user.id)
+
+                  if dbuser.nil?
+                    dbuser = User.create(
+                      :campfire_id => user.id,
+                      :name => user.name
+                    )
+                  else
+                    dbuser.update(:name => user.name)
+                  end
+
+                  message.user = dbuser
+                  process(message)
+                end
+              else
+                process(message)
+              end
+
+            rescue => e
+              log_error(e)
+            end
+
+          end
+        end
+
+        trap("INT") { EM.stop; raise SystemExit }
+      end
+
+    rescue Exception => e # leave the room if we crash
+      if e.kind_of?(SystemExit)
+        room.leave
+        exit 0
+      else
+        log_error(e)
+        room.leave
+        exit 1
+      end
+    end
+
+    def process(message)
+      logger.debug "processing #{message} (#{message.person} - #{message.body})"
+
+      # ignore messages from ourself
+      return if [message.person, message.person_full_name].include? self.name
+
+      plugins.each do |plugin|
+        begin
+          if plugin.accepts?(message)
+            logger.debug "sending to plugin #{plugin} (priority #{plugin.priority})"
+            status = plugin.process(message)
+            if status == Plugin::HALT
+              logger.debug "plugin chain halted"
+              break
+            end
+          end
+        rescue Exception => e
+          say("Oops, #{plugin.class} threw an exception. Enable debugging to see it.") unless debug
+          log_error(e)
+          break
+        end
+      end
+
+      logger.debug "done processing #{message}"
+    end
+
+    # determine if a message is addressed to the bot. if so, store the command in the message
+    def addressed_to_me?(message)
+      m = message.body.match(/^#{name}(?:[,:]\s*|\s+)(.*)/i)
+      m ||= message.body.match(/^\s*(.*?)(?:,\s+)?\b#{name}[.!?\s]*$/i)
+      message.command = m[1] if m
+    end
+
+    def log_error(e)
+      msg = "Exception: #{e.class}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+      logger.error(msg)
+      paste(msg) if debug
+    end
+
+  end
+end

data/lib/campfire/sample_plugin.rb

@@ -0,0 +1,56 @@
+# Sample Campfire plugin. Plugins must be placed in the plugins directory in order to be loaded.
+class SamplePlugin < Campfire::PollingBot::Plugin
+  # accept - specify which kinds of messages this plugin accepts. Put each type on its own line.
+  # You may optionally set :addressed_to_me => true to get only messages addressed to the bot.
+  # For example,
+  #   accept :text_message, :addressed_to_me => true
+  # Will only accept text messages that are in the form "<bot name>, ..." or "... <bot name>".
+  # The body of the message minus the bot name will be returned by the 'command' method of the
+  # message.
+  #
+  # Message types are:
+  #  - :all - all messages
+  #  - :text_message - normal user text message
+  #  - :paste_message - a paste
+  #  - :enter_message - sent when a user enters the room
+  #  - :leave_message - sent when a user leaves the room
+  #  - :kick_message - sent when a user times out from inactivity
+  #  - :lock_message - sent when the room is locked
+  #  - :unlock_message - sent when the room is unlocked
+  #  - :allow_guests_message - sent when guest access is turned on
+  #  - :disallow_guests_message - sent when guest access is turned off
+  #  - :topic_change_message - sent when the room's topic is changed
+
+  accepts :text_message, :addressed_to_me => true
+  accepts :paste_message
+  
+  # priority is used to determine the plugin's order in the plugin queue. A higher number represents
+  # a higher priority. There are no upper or lower bounds. If you don't specify a priority, it defaults
+  # to 0.
+  
+  priority 10
+  
+  # If you need to do any one-time setup when the plugin is initially loaded, do it here. Optional. 
+  def initialize
+  end
+  
+  # If your plugin implements the heartbeat method, it will be called every time the bot polls the room
+  # for activity (currently every 3 seconds), whether or not there are any new messages. The heartbeat
+  # method is optional. It does not take any parameters.
+  def heartbeat
+  end
+  
+  # process is the only method your plugin needs to implement. This is called by the bot whenever it
+  # has a new message that matches one of the message types accepted by the plugin. See Campfire::Message
+  # for message documentation.
+  # If no other plugins should receive the message after this plugin, return HALT.
+  def process(message)
+  end
+  
+  # help is actually functionality provided by another plugin, HelpPlugin. Just return an array of
+  # ['command', 'description'] tuples
+  def help
+    [['some command', 'description of some command'],
+     ['some other command', 'description of some other command']]
+  end
+end

data/lib/campfire/version.rb

@@ -0,0 +1,3 @@
+module Campfire
+  VERSION = "1.0.1"
+end

data/lib/wesabot.rb

@@ -0,0 +1,3 @@
+require "campfire/version"
+require "campfire/configuration"
+require "campfire/polling_bot"

data/spec/.gitignore

@@ -0,0 +1 @@
+test.sqlite

data/spec/polling_bot_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Campfire::PollingBot do
+  before do
+    @bot = FakeBot.new
+  end
+
+  it 'recognizes commands addressed to itself' do
+    messages = ["wes", "wes?", "wes hi", "wes, hi", "hi, wes", "hi wes", 
+                "wes: hi"]
+    messages.each do |m|
+      @bot.addressed_to_me?(Campfire::TextMessage.new(:body => m)).should be_true
+    end
+  end 
+
+  it 'does not recognize commands not addressed to itself' do
+    messages = ["hi", "western", "weswes?"]
+    messages.each do |m|
+      @bot.addressed_to_me?(Campfire::TextMessage.new(:body => m)).should be_false
+    end
+  end 
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,190 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+$:.push File.expand_path("../lib", __FILE__)
+require 'wesabot'
+require 'rspec'
+
+Campfire::PollingBot::Plugin.load_plugin_classes
+
+class FakeBot < Campfire::PollingBot
+  def initialize
+    self.name = 'Wes'
+    self.config = Campfire::Configuration.new(:datauri => "sqlite3://#{File.expand_path('../test.sqlite', __FILE__)}")
+    Campfire::PollingBot::Plugin.load_all(self)
+  end
+
+  def say(message)
+    transcript << [:say, message]
+  end
+
+  def paste(message)
+    transcript << [:paste, message]
+  end
+
+  def say_random(messages)
+    transcript << [:say, messages.first]
+  end
+
+  def transcript
+    @transcript ||= []
+  end
+end
+
+RSpec.configure do |config|
+  def saying(what)
+    message Campfire::TextMessage, :body => what
+  end
+
+  alias :asking :saying
+  alias :say    :saying
+
+  def entering
+    message Campfire::EnterMessage
+  end
+
+  alias :enter :entering
+
+  def leaving
+    message Campfire::LeaveMessage
+  end
+
+  alias :leave :leaving
+
+  def message(type, params={})
+    bot = FakeBot.new
+    @plugin.class.bot = bot
+    message = type.new(params)
+    @user ||= User.create(:name => "John Tester")
+    message.user = @user
+    @plugin.process(message) if @plugin.accepts?(message)
+    return bot.transcript
+  end
+
+  def make_wes_say(what)
+    MakeWesSend.new.and_say(what)
+  end
+
+  def make_wes_paste(what)
+    MakeWesSend.new.and_paste(what)
+  end
+
+  def make_wes_say_something
+    MakeWesSaySomething.new
+  end
+
+  alias :make_wes_say_anything :make_wes_say_something
+
+  module MessagePrinter
+    def print_messages(messages)
+      messages.map {|e| "  #{e.first} #{e.last.inspect}"}.join("\n")
+    end
+  end
+
+  class MakeWesSend
+    include MessagePrinter
+
+    def matches?(actual)
+      @actual = actual
+
+      if actual.size != expected.size
+        @failure = [:size, actual.size, expected.size]
+        return false
+      end
+
+      actual.zip(expected).each do |a, e|
+        if a.first != e.first
+          @failure = [:type, a, e]
+          return false
+        end
+
+        case e.last
+        when Regexp
+          if a.last !~ e.last
+            @failure = [:match, a, e]
+            return false
+          end
+        else
+          if e.last != a.last
+            @failure = [:equal, a, e]
+            return false
+          end
+        end
+      end
+
+      return true
+    end
+
+    def failure_message
+      failure_type, actual, expected = *@failure
+
+      case failure_type
+      when :size
+        "expected #{expected} message(s):\n\n" +
+          print_messages(@expected) +
+        "\n\ngot #{actual} message(s):\n\n" +
+          print_messages(@actual)
+      when :type
+        "expected Wes to #{expected.first} #{expected.last.inspect}, " +
+        "but got #{actual.first} #{actual.last.inspect}"
+      when :match
+        "expected Wes to #{expected.first} something matching #{expected.last.inspect}, " +
+        "but got #{actual.last.inspect}"
+      when :equal
+        "expected Wes to #{expected.first} #{expected.last.inspect}, " +
+        "but got #{actual.last.inspect}"
+      else
+        @failure.inspect
+      end
+    end
+
+    def negative_failure_message
+      "expected not to get the following message(s), but did:\n\n" +
+        print_messages(@expected)
+    end
+
+    def and(expected)
+      expect nil, expected
+    end
+
+    def and_say(expected)
+      expect :say, expected
+    end
+
+    def and_paste(expected)
+      expect :paste, expected
+    end
+
+    private
+
+    def expect(type, message)
+      type ||= @last_type
+      expected << [type, message]
+      @last_type = type
+      return self
+    end
+
+    def expected
+      @expected ||= []
+    end
+  end
+
+  class MakeWesSaySomething
+    include MessagePrinter
+
+    def matches?(actual)
+      @actual = actual
+      actual.any?
+    end
+
+    def failure_message
+      "expected Wes to say something, but he didn't"
+    end
+
+    def negative_failure_message
+      "expected Wes not to say anything, but he did:\n\n" +
+        print_messages(@actual)
+    end
+  end
+end

data/wesabot.gemspec

@@ -0,0 +1,55 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "campfire/version"
+
+Gem::Specification.new do |s|
+  s.name        = "wesabot"
+  s.version     = Campfire::VERSION
+  s.authors     = ["Brad Greenlee", "André Arko", "Brian Donovan"]
+  s.email       = ["brad@footle.org", "andre@arko.net", "me@brian-donovan.com"]
+  s.homepage    = "https://github.com/hackarts/wesabot"
+  s.summary     = %q{Wesabe's Campfire bot framework}
+  s.description = %q{Wesabot is a Campfire bot framework we've been using and 
+    developing at Wesabe since not long after our inception. It started as a 
+    way to avoid parking tickets near our office ("Wes, remind me in 2 hours 
+    to move my car"), and has evolved into an essential work aid. When you 
+    enter the room, Wes greets you with a link to the point in the transcript 
+    where you last left. You can also ask him to bookmark points in the 
+    transcript, send an sms message (well, an email) to someone, or even post 
+    a tweet, among other things. His functionality is easily extendable via 
+    plugins.}
+
+  s.rubyforge_project = "wesabot"
+
+  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"]
+
+  ### core dependencies
+  s.add_dependency "tinder", "~> 1.7.0"
+  s.add_dependency "data_mapper", "~> 1.1"
+  s.add_dependency "dm-sqlite-adapter", "~> 1.1"
+  s.add_dependency "daemons"
+  s.add_dependency "i18n"
+  s.add_dependency "firering", "~> 1.2.0"
+
+  ### plugin dependencies
+
+  # airbrake
+  s.add_dependency "nokogiri"
+  s.add_dependency "rest-client"
+
+  # image_search
+  s.add_dependency "httparty" # also used by twitter_search
+  s.add_dependency "google-search"
+
+  # remind_me
+  s.add_dependency "chronic"
+
+  ### development dependencies  
+  s.add_development_dependency "rspec", "~> 2.6.0"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "ruby-debug"
+
+end