wesabot 1.0.1

data/lib/campfire/polling_bot/plugin.rb

@@ -0,0 +1,162 @@
+# Campfire AbstractPollingBot Plugin base class
+#
+# To create a plugin, extend from this class, and just drop it into the plugins directory.
+# See sample_plugin.rb for more information.
+#
+require 'dm-core'
+require 'dm-migrations'
+
+module Campfire
+  class PollingBot
+    class Plugin
+      attr_accessor :config
+
+      def initialize
+        # load the config file if we have one
+        name = self.to_s.gsub(/([[:upper:]]+)([[:upper:]][[:lower:]])/,'\1_\2').
+            gsub(/([[:lower:]\d])([[:upper:]])/,'\1_\2').
+            tr("-", "_").
+            downcase
+        filepath = File.join(self.class.directory, "#{name}.yml")
+        if File.exists?(filepath)
+          self.config = YAML.load_file(filepath)
+        else
+          self.config = {}
+        end
+      end
+
+      # keep track of subclasses
+      def self.inherited(klass)
+        # save the plugin's directory
+        filepath = caller[0].split(':')[0]
+        klass.directory = File.dirname(caller[0].split(':')[0])
+        super if defined? super
+      ensure
+        ( @subclasses ||= [] ).push(klass).uniq!
+      end
+
+      def self.subclasses
+        @subclasses ||= []
+        @subclasses.inject( [] ) do |list, subclass|
+          list.push(subclass, *subclass.subclasses)
+        end
+      end
+
+      def self.directory=(dir)
+        @directory = dir
+      end
+
+      def self.directory
+        @directory
+      end
+
+      # bot accessor
+      def self.bot
+        @@bot
+      end
+      def self.bot=(bot)
+        @@bot = bot
+      end
+      attr_writer :bot
+      def bot
+        @bot || self.class.bot
+      end
+
+      def logger
+        bot.logger
+      end
+
+      HALT = 1 # returned by a command when command processing should halt (continues by default)
+
+      def self.load_all(bot)
+        self.bot = bot
+
+        load_plugin_classes
+
+        # set up the database now that the plugins are loaded
+        setup_database(bot.config.datauri)
+
+        plugin_classes = self.subclasses.sort {|a,b| b.priority <=> a.priority }
+        # initialize plugins
+        plugins = plugin_classes.map { |p_class| p_class.new }
+        return plugins
+      end
+
+      def self.load_plugin_classes
+        # add each plugin dir to the load path
+        Dir.glob(File.dirname(__FILE__) + "/plugins/*").each {|dir| $LOAD_PATH << dir }
+        # load core first
+        paths  = Dir.glob(File.dirname(__FILE__) + "/plugins/shared/*.rb")
+        # load all models & plugins
+        paths += Dir.glob(File.dirname(__FILE__) + "/plugins/*/*.rb")
+        paths.each do |path|
+          begin
+            path.match(/(.*?)\.rb$/) && (require $1)
+          rescue Exception => e
+            $stderr.puts "Unable to load #{path}: #{e.class}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+          end
+        end
+      end
+
+      # set up the plugin database
+      def self.setup_database(datauri)
+        DataMapper.setup(:default, datauri)
+        DataMapper.auto_upgrade!
+        # not related to setting up the database, but for lack of a better place....
+        DataMapper::Model.raise_on_save_failure = true
+      end
+
+      # method to set or get the priority. Higher value == higher priority. Default is 0
+      # command subclasses set their priority like so:
+      #   class FooPlugin << Campfire::PollingBot::Plugin
+      #     priority 10
+      #   ...
+      def self.priority(value = nil)
+        if value
+          @priority = value
+        end
+        return @priority || 0
+      end
+
+      # convenience method to get the priority of a plugin instance
+      def priority
+        self.class.priority
+      end
+
+      # called from Plugin objects to indicate what kinds of messages they accept
+      # if the :addressed_to_me flag is true, it will only accept messages addressed
+      # to the bot (e.g. "Wes, ____" or "______, Wes")
+      # Examples:
+      #   accepts :text_message, :addressed_to_me => true
+      #   accepts :enter_message
+      #   accepts :all
+      def self.accepts(message_type, params = {})
+        @accepts ||= {}
+        if message_type == :all
+          @accepts[:all] = params[:addressed_to_me] ? :addressed_to_me : :for_anyone
+        else
+          klass = Campfire.const_get(message_type.to_s.gsub(/(?:^|_)(\S)/) {$1.upcase})
+          @accepts[klass] = params[:addressed_to_me] ? :addressed_to_me : :for_anyone
+        end
+      end
+
+      # returns true if the plugin accepts the given message type
+      def self.accepts?(message)
+        if @accepts[:all]
+          @accepts[:all] == :addressed_to_me ? bot.addressed_to_me?(message) : true
+        elsif @accepts[message.class]
+          @accepts[message.class] == :addressed_to_me ? bot.addressed_to_me?(message) : true
+        end
+      end
+
+      # convenience method to call accepts on a plugin instance
+      def accepts?(message)
+        self.class.accepts?(message)
+      end
+
+      def to_s
+        self.class.to_s
+      end
+    end
+  end
+end

data/lib/campfire/polling_bot/plugins/airbrake/.gitignore

@@ -0,0 +1 @@
+airbrake_plugin.yml

data/lib/campfire/polling_bot/plugins/airbrake/airbrake/api.rb

@@ -0,0 +1,48 @@
+require 'nokogiri'
+require 'rest-client'
+
+module Airbrake
+  class API
+    def initialize(domain, auth_token)
+      @host = "#{domain}.airbrakeapp.com"
+      @auth_token = auth_token
+    end
+
+    def resolve_error(error_id, resolved=true)
+      api_put("/errors/#{error_id}", {}, :group => {:resolved => resolved})
+    end
+
+    def errors(show_resolved=false)
+      doc = Nokogiri::XML(api_get("/errors.xml", :show_resolved => show_resolved))
+      doc.xpath("/groups/group").map {|node| Airbrake::Error.from_xml(node) }
+    end
+
+    def error_url(error)
+      error_id = error.is_a?(Airbrake::Error) ? error.error_id : error
+      "https://#{@host}/errors/#{error_id}"
+    end
+
+    private
+
+    def api_uri(endpoint, query = {})
+      query = {:auth_token => @auth_token}.update(query)
+      uri = URI::HTTPS.build(:host => @host, :path => endpoint, :query => to_query(query))
+      return uri.to_s
+    end
+
+    # convert a hash of param to a query string
+    def to_query(params)
+      params.map{|k,v| "#{CGI::escape(k.to_s)}=#{CGI::escape(v.to_s)}"}.join('&')
+    end
+
+    def api_get(endpoint, query = {})
+      RestClient.get(api_uri(endpoint, query))
+    end
+
+    def api_put(endpoint, query = {}, params = {})
+      return RestClient.put(api_uri(endpoint, query), params)
+    rescue RestClient::Exception => e
+      return e.response
+    end
+  end
+end

data/lib/campfire/polling_bot/plugins/airbrake/airbrake/error.rb

@@ -0,0 +1,51 @@
+module Airbrake
+  class Error
+    include DataMapper::Resource
+    property :id, Serial
+    property :error_id, Integer, :required => true
+
+    attr_accessor :field
+
+    # Given a block of XML returned from the Airbrake API, return an
+    # Airbrake::Error object
+    def self.from_xml(xml)
+      field = {}
+      xml.xpath('./*').each do |node|
+        content = node.content
+        # convert to proper ruby types
+        type = node.attributes['type'] && node.attributes['type'].value
+        case type
+        when "boolean"
+          content = content == "true"
+        when "datetime"
+          content = Time.parse(content)
+        when "integer"
+          content = content.to_i
+        end
+        key = node.name.tr('-','_')
+        field[key.to_sym] = content
+      end
+      error = new()
+      error.field = field
+      error.error_id = field[:id]
+      return error
+    end
+
+    def summary
+      "#{@field[:error_message]} at #{@field[:file]}:#{@field[:line_number]}"
+    end
+
+    def [](key)
+      key = key.to_s.tr('-','_').to_sym
+      @field[key]
+    end
+
+    def eql?(other)
+      self.error_id.eql?(other.error_id)
+    end
+
+    def hash
+      self.error_id.hash
+    end
+  end
+end

data/lib/campfire/polling_bot/plugins/airbrake/airbrake_plugin.rb

@@ -0,0 +1,63 @@
+require 'airbrake/api'
+require 'airbrake/error'
+
+class AirbrakePlugin < Campfire::PollingBot::Plugin
+  accepts :text_message, :addressed_to_me => true
+  priority 10
+  
+  def initialize
+    super
+    @api = Airbrake::API.new(config['domain'], config['auth_token'])
+  end
+
+  def process(message)
+    case message.command
+    when /((?:un(?:-)?)?resolve) error (?:#|number)?\s*(\d+)/
+      action, error_num = $1, $2
+      res = @api.resolve_error(error_num, action == "resolve")
+      case res.code
+      when 200
+        bot.say("Ok, #{action}d error ##{error_num}")
+      when 404
+        bot.say("Hmm. Airbrake couldn't find error ##{error_num}")
+      else
+        bot.say("Huh. Airbrake gave me this response:")
+        bot.paste(res.to_s)
+      end
+      return HALT
+    end
+  end
+
+  def heartbeat
+    # check every <check_interval> seconds (heartbeat is called every 3 sec)
+    num_heartbeats = config['check_interval'] / Campfire::PollingBot::HEARTBEAT_INTERVAL
+    @heartbeat_counter ||= 0
+    @heartbeat_counter += 1
+    return unless (@heartbeat_counter % num_heartbeats) == 1
+    handle_errors
+  end
+
+  def handle_errors
+    # fetch errors we know about, announce new ones, and remove resolved ones
+    unresolved_errors = @api.errors
+    known_errors = Airbrake::Error.all
+    new_errors = unresolved_errors - known_errors
+    resolved_errors = known_errors - unresolved_errors
+    resolved_errors.each {|e| e.destroy }
+    new_errors.each {|e| e.save }
+    announce(new_errors) if new_errors.any?
+  end
+
+  def announce(errors)
+    msg = "Got #{errors.length} new error#{errors.length > 1 ? 's' : ''} from Airbrake" + 
+          (errors.length > 5 ? ". Here are the first 5:" : ":")
+    bot.say(msg)
+    errors.first(5).each { |e| bot.say("#{e.summary} (#{@api.error_url(e)})") }
+  end
+
+    # return array of available commands and descriptions
+  def help
+    [["resolve <error number>", "mark an error as resolved"],
+     ["unresolve <error number>", "mark an error as unresolved"]]
+  end
+end

data/lib/campfire/polling_bot/plugins/airbrake/airbrake_plugin.yml.sample

@@ -0,0 +1,3 @@
+domain: your-airbrake-domain
+auth_token: your-airbrake-auth-token
+check_interval: 300 # seconds between API checks

data/lib/campfire/polling_bot/plugins/bookmark/bookmark.rb

@@ -0,0 +1,15 @@
+# used by BookmarksPlugin
+class Bookmark
+  include DataMapper::Resource
+  property :id,           Serial
+  property :room,         Integer, :required => true, :index => true
+  property :message_id,   Integer, :required => true 
+  property :person,       String, :index => true
+  property :name,         String, :index => true
+  property :timestamp,    Time, :required => true, :index => true
+
+  # return link to bookmark
+  def link
+    "/room/#{self.room}/transcript/message/#{self.message_id}"
+  end
+end

data/lib/campfire/polling_bot/plugins/bookmark/bookmark_plugin.rb

@@ -0,0 +1,89 @@
+# Plugin to allow saving of transcript bookmarks
+class BookmarkPlugin < Campfire::PollingBot::Plugin
+  accepts :text_message, :addressed_to_me => true
+  
+  def process(message)
+    case message.command
+    when /^(?:add |create )?bookmark:?\s*(?:this as:?)?\s*("?)(.*?)\1$/i
+      save_bookmark(message, $2)
+      bot.say("Ok, saved bookmark: #{$2}")
+      return HALT
+    when /(?:list|show) (\S+) bookmarks/i, /(?:list|show) bookmarks for (\S+)/i
+      list_bookmarks(message.person, $1)
+      return HALT
+    when /(list|show) bookmarks$/
+      list_bookmarks(message.person, message.person)
+      return HALT
+    when /delete bookmark (?:#\s*)?(\d+)/
+      delete_bookmark(message.person, $1.to_i)
+      return HALT
+      
+    end
+  end
+  
+  # return array of available commands and descriptions
+  def help
+    [["bookmark: <name>", "bookmark the current location"]]
+  end
+  
+  private
+  
+  def save_bookmark(message, name)
+    Bookmark.create(:person => message.person, 
+                    :name => name, 
+                    :room => bot.room.id,
+                    :message_id => message.message_id, 
+                    :timestamp => Time.now)
+  end
+
+  def list_bookmarks(current_person, request_person)
+    case request_person.downcase
+    when 'my', 'me'
+      request_person = current_person
+    else
+      request_person.gsub!(/'s$/i,'')
+    end
+    request_person.capitalize!
+    
+    case request_person
+    when /everyone/i, /all/i      
+      if (bookmarks = Bookmark.all(:order => [:name])).any?
+        bot.say("Here are all the bookmarks I have:")
+        bookmarks.each do |bookmark|
+          bot.say("#{bookmark.id} - #{bookmark.name} (#{bookmark_link(bookmark)}) by #{bookmark.person}")
+        end
+      end
+      return
+    else
+      bookmarks = Bookmark.all(:conditions => {:person => request_person}, :order => [:name])
+      if bookmarks.any?
+        if request_person == current_person
+          bot.say("Here are the bookmarks I have for you, #{current_person}:")
+        else
+          bot.say("Here are the bookmarks for #{request_person}:")
+        end
+        bookmarks.each do |bookmark|
+          bot.say("#{bookmark.id} - #{bookmark.name} (#{bookmark_link(bookmark)})")
+        end
+        return
+      end
+    end
+    bot.say("I couldn't find any bookmarks for #{request_person}")
+  end
+  
+  def delete_bookmark(current_person, id)
+    bookmark = Bookmark.get(id)
+    if bookmark.person == current_person
+      bookmark.destroy
+      bot.say("Ok, I've deleted bookmark ##{id}.")
+    else
+      bot.say("Sorry, #{current_person}, but I couldn't find a bookmark with that id that belongs to you.")
+    end
+  end
+
+  # return link to bookmark
+  def bookmark_link(bookmark)
+    bot.base_uri + bookmark.link
+  end
+
+end

data/lib/campfire/polling_bot/plugins/debug/debug_plugin.rb

@@ -0,0 +1,23 @@
+# Toggle debug mode
+class DebugPlugin < Campfire::PollingBot::Plugin
+  accepts :text_message, :addressed_to_me => true
+  priority 100
+  
+  def process(message)
+    case message.command
+    when /(enable|disable) debug/i
+      if $1 == 'enable'
+        bot.debug = true
+      else
+        bot.debug = false
+      end
+      bot.say("ok, debugging is #{bot.debug ? 'enabled' : 'disabled'}")
+      return HALT
+    end
+  end
+
+  # return array of available commands and descriptions
+  def help
+    [['<enable|disable> debugging', "enable or disable debug mode"]]
+  end
+end

data/lib/campfire/polling_bot/plugins/deploy/deploy_plugin.rb

@@ -0,0 +1,155 @@
+require 'open-uri'
+
+# Plugin to get a list of commits that are on deck to be deployed
+class DeployPlugin < Campfire::PollingBot::Plugin
+  accepts :text_message, :addressed_to_me => true
+
+  def process(message)
+    case message.command
+    when /deploy\s([^\s\!]+)(?:(?: to)? (staging|nine|production))?( with migrations)?/
+      project, env, migrate = $1, $2, $3
+      name = env ? "#{project} #{env}" : project
+      env ||= "production"
+
+      if not projects.any?
+        bot.say("Sorry #{message.person}, I don't know about any projects. Please configure the deploy plugin.")
+        return HALT
+      end
+
+      project ||= default_project
+      if project.nil?
+        bot.say("Sorry #{message.person}, I don't have a default project. Here are the projects I do know about:")
+        bot.paste(projects.keys.sort.join("\n"))
+        return HALT
+      end
+      project.downcase!
+
+      info = project_info(project)
+      if info.nil?
+        bot.say("Sorry #{message.person}, I don't know anything about #{name}. Here are the projects I do know about:")
+        bot.paste(projects.keys.sort.join("\n"))
+        return HALT
+      end
+
+      bot.say("Okay, trying to deploy #{name}...")
+
+      begin
+        deploy = migrate ? "deploy:migrations" : "deploy"
+        git(project, "bundle exec cap #{env} #{deploy}")
+      rescue => e
+        bot.log_error(e)
+        bot.say("Sorry #{message.person}, I couldn't deploy #{name}.")
+        return HALT
+      end
+
+      bot.say("Done.")
+      return HALT
+
+    when /on deck(?: for ([^\s\?]+)( staging)?)?/
+      project, staging = $1, $2
+      project ||= default_project
+      name = staging ? "#{project} staging" : project
+
+      if not projects.any?
+        bot.say("Sorry #{message.person}, I don't know about any projects. Please configure the deploy plugin.")
+        return HALT
+      end
+
+      if project.nil?
+        bot.say("Sorry #{message.person}, I don't have a default project. Here are the projects I do know about:")
+        bot.paste(projects.keys.sort.join("\n"))
+        return HALT
+      end
+      project.downcase!
+
+      info = project_info(project)
+      if info.nil?
+        bot.say("Sorry #{message.person}, I don't know anything about #{name}. Here are the projects I do know about:")
+        bot.paste(projects.keys.sort.join("\n"))
+        return HALT
+      end
+
+      range = nil
+      begin
+        range = "#{deployed_revision(project, staging)}..HEAD"
+        shortlog = project_shortlog(project, range)
+      rescue => e
+        bot.log_error(e)
+        bot.say("Sorry #{message.person}, I couldn't get what's on deck for #{name}.")
+        return HALT
+      end
+
+      if shortlog.nil? || shortlog =~ /\A\s*\Z/
+        bot.say("There's nothing on deck for #{name} right now.")
+        return HALT
+      end
+
+      bot.say("Here's what's on deck for #{name}:")
+      bot.paste("$ git shortlog #{range}\n\n#{shortlog}")
+
+      return HALT
+    end
+  end
+
+  def help
+    help_lines = [
+      ["what's on deck for <project>?", "shortlog of changes not yet deployed to production"],
+      ["what's on deck for <project> staging?", "shortlog of changes not yet deployed to staging"],
+    ]
+    if default_project
+      help_lines << ["what's on deck?", "shortlog of changes not yet deployed to #{default_project}"]
+    end
+    return help_lines
+  end
+
+  def projects
+    (config && config['projects']) || {}
+  end
+
+  def default_project
+    (config && config['default_project']) ||
+      (projects.size == 1 ? projects.keys.first : nil)
+  end
+
+private
+
+  def project_info(project)
+    projects[project]
+  end
+
+  def project_shortlog(project, treeish)
+    info = project_info(project)
+    return nil if info.nil?
+
+    return git(project, "git shortlog #{treeish}")
+  end
+
+  def deployed_revision(project, staging = false)
+    info = project_info(project)
+    return nil if info.nil?
+
+    host = staging ? info['staging'] : info['url']
+    return nil if host.nil?
+
+    return open("http://#{host}/REVISION").read.chomp
+  end
+
+  def repository_path(project)
+    File.expand_path File.join(config["repository_base_path"], "#{project}")
+  end
+
+  def git(project, cmd)
+    dir = repository_path(project)
+    out = Dir.chdir(dir) do
+      # don't want output from the pull
+      system("git pull")
+      `#{cmd}`
+    end
+
+    unless $?.exitstatus.zero?
+      raise "attempt to run `#{cmd}` in #{dir} failed with status #{$?.exitstatus}\n#{out}"
+    end
+
+    return out
+  end
+end

data/lib/campfire/polling_bot/plugins/deploy/deploy_plugin.yml.sample

@@ -0,0 +1,9 @@
+# config file for DeployPlugin
+# sites are expected to have a file at /REVISION
+# containing the git sha of the deployed revision
+repository_base_path: src
+default_project: my_super_site
+projects:
+  my_super_site:
+    url: www.example.com
+    staging: staging.example.com