campfire-bot 0.0.1

data/plugins/lolcats.rb

@@ -0,0 +1,17 @@
+require 'open-uri'
+require 'hpricot'
+require 'tempfile'
+
+class LolCats < CampfireBot::Plugin
+  on_command 'lolcat', :lolcats
+  
+  def initialize
+    @log = Logging.logger["CampfireBot::Plugin::Lolcat"]
+  end
+  
+  def lolcats(msg)
+    # Scrape random lolcat
+    lolcat = (Hpricot(open('http://icanhascheezburger.com/?random#top'))/'div.entry img').first['src']
+    msg.speak(lolcat)
+  end
+end

data/plugins/our_quotes.rb

@@ -0,0 +1,195 @@
+require 'yaml'
+
+# Remember quotes and quips added upon request.  Rather than pulling
+# public quoes form the internet, the idea is that you can maintain
+# your own list of quotes said by people at your campfire.
+#
+# Since this plugin maintains long-term persistent data, not just
+# temporary state, its data file lives under var/ instead of tmp/.
+#
+# You can import from the eggdrop QuoteBot.log with this, which will
+# overwrite any existing campfire-bot quotes:
+#
+#   ruby -e '
+#     require "yaml"
+#     log = File.readlines("QuoteBot.log").collect { |l|
+#       action, scope, quoter, room, id, quote = l.split(" ", 6)
+#       quote.gsub!(/\x03\d\d/, "") # remove IRC color codes
+#       [action, quoter, room, id.sub(/^[(]#/, "").sub(/[)]$/, "").to_i,
+#        nil, quote]
+#     }
+#     File.open("var/quote-log.yml", "w") do |out|
+#       YAML.dump(log, out)
+#     end
+#     puts "wrote #{log.size} log entries"
+#   '
+#
+# Issues:
+#
+# * The entire log is rewritten after each add/del, which takes 1.2
+#   sec for my 3k quotes.  It's the YAML.dump call that's slow.  An
+#   alternative would be to store each log entry as a document and only
+#   append to the file.  However, an incomplete write would corrupt the
+#   file.  Maybe there's a way to discard the last, corrupt yaml
+#   document?  For now, it's fast enough.
+#
+# * Would be nice when there are multiple matches to iterate through
+#   them when the same query is repeated.
+#
+# * There is another quote plugin in quote.rb whose model is to pull
+#   quotes from the internet.  The upside is you have a list of quotes
+#   to start with.  The downside is that it doesn't foster much sense
+#   of community nor develop common culture.   To avoid a command name
+#   collision, the quote recall command of this plugin may be
+#   configured.  The default commant is "!ourquote", but "!quote" is
+#   more natural.
+#
+class OurQuotes < CampfireBot::Plugin
+  on_command 'addquote', :addquote
+  on_command 'rmquote', :rmquote
+  # Configure with "our_quote_recall_command: quote"
+  #on_command 'quote', :quote
+
+  config_var :data_file, File.join(BOT_ROOT, 'var', 'quote-log.yml')
+  config_var :recall_command, "ourquote"
+  config_var :debug_enabled, false
+
+  attr_reader :use_htmlentities
+
+  def initialize()
+    super
+
+    self.class.on_command recall_command.to_s, :quote
+
+    # Put this in the constructor so we don't fail to find htmlentities
+    # every time we fetch a bug title.
+    begin
+      require 'htmlentities'
+      @use_htmlentities = true
+    rescue LoadError
+      debug "Falling back to 'cgi', install 'htmlentities' better unescaping"
+      require 'cgi'
+    end
+
+    @log = begin
+        YAML::load(File.read(@data_file))
+      rescue Errno::ENOENT => e
+        debug e
+        []
+      end
+  end
+
+  def debug(spew)
+    $stderr.puts "#{self.class.name}: #{spew}" if debug_enabled
+  end
+
+  def addquote(msg)
+    debug "Addquote requested: #{msg}"
+    if msg[:message].empty?
+      msg.speak "Please include the text of the quote and attribution."
+      return
+    end
+    append_add(msg[:person], msg[:room].name, msg[:message])
+    # Show the users quote numberes that start with 1 not 0
+    msg.speak "Added quote ##{quotes.length}."
+  end
+
+  def append_add(quoter, room, quote)
+    debug "ADD: #{quotes.length + 1} #{quote}"
+    @log.push ["ADD", quoter, room, quotes.length + 1, Time.now, decode(quote)]
+    write_log
+  end
+
+  def decode(str)
+    # Unicode decode: The "&" of "&lt;" appear as "\\u0026".
+    html = str.gsub(/\\u([0-9a-f]{4})/i) { eval "0x#{$1}.chr" }
+    html_decode(html)
+  end
+
+  # Returns the non-HTML version of the given string using
+  # htmlentities if available, or else unescapeHTML
+  def html_decode(html)
+    if use_htmlentities
+      HTMLEntities.new.decode(html)
+    else
+      CGI.unescapeHTML(html)
+    end
+  end
+
+  def quote(msg)
+    q = msg[:message]
+    id = q.to_i
+    # If numeric
+    if id.to_s == q
+      msg.speak quotes[id - 1] ? format_quote(id) : "No quote ##{id}."
+    else
+      matches = select_quote_ids {|quote| quote.include?(q) }
+      msg.speak matches.empty? ?
+        "No matching quotes." :
+        format_quote(matches[rand(matches.length)]) +
+          (q == "" ? "" :
+           " (#{matches.size} match#{"es" if matches.size != 1})")
+    end
+  end
+
+  def format_quote(id)
+    "##{id} #{quotes[id - 1]}"
+  end
+
+  def select_quote_ids
+    returning([]) {|ids|
+      quotes.each_with_index {|quote,idx|
+        if !quote.nil? && yield(quote)
+          ids.push(idx + 1)
+        end
+      }
+    }
+  end
+
+  def rmquote(msg)
+    q = msg[:message]
+    id = q.to_i
+    # If numeric
+    if id.to_s != q || !quotes[id - 1]
+      msg.speak "No quote ##{q}."
+      return
+    end
+    append_del(msg[:person], msg[:room].name, id)
+    msg.speak "Deleted quote ##{id}."
+  end
+
+  def append_del(rmer, room, id)
+    debug "DEL: #{quotes.length} #{id}"
+    @log.push ["DEL", rmer, room, id, Time.now, nil]
+    write_log
+  end
+
+  def quotes
+    return @quotes if @quotes
+    debug "Rebuilding @quotes from @log of length #{@log.size}"
+    @quotes = []
+    @log.each { |action, quoter, room, id, ts, quote|
+      case action
+        when "ADD" then
+          raise "Bad ID: #{id}" if id - 1 != @quotes.length
+          @quotes.push quote
+        when "DEL" then
+          @quotes[id - 1] = nil
+          # Allow any trailing IDs with nil quotes to be reused
+          @quotes.pop while @quotes.last.nil? && !@quotes.empty?
+        else raise "Unknown log action #{action}"
+      end
+    }
+    @quotes
+  end
+
+  def write_log
+    debug "Writing #{@log.length} log entries"
+    File.open("#{data_file}.tmp", 'w') do |out|
+      YAML.dump(@log, out)
+    end
+    debug "Renaming .tmp file to #{data_file}"
+    File.rename("#{data_file}.tmp", data_file)
+    @quotes = nil
+  end
+end

data/plugins/quote.rb

@@ -0,0 +1,31 @@
+require 'open-uri'
+require 'hpricot'
+
+class Quote < CampfireBot::Plugin
+  on_command 'quote', :quote
+  
+  def quote(msg)
+    # Get our quotes from the web
+    url = "http://quotes4all.net/rss/000010110/quotes.xml"
+    response = ''
+
+    begin
+      # open-uri RDoc: http://stdlib.rubyonrails.org/libdoc/open-uri/rdoc/index.html
+      open(url, "User-Agent" => "Ruby/#{RUBY_VERSION}",
+        "From" => "Campfire") { |f|
+                                  
+        # Save the response body
+        response = f.read
+      }
+    
+      # HPricot RDoc: http://code.whytheluckystiff.net/hpricot/
+      doc = Hpricot(response)
+
+      msg.speak((doc/"*/item/description").inner_html.gsub(/<\/?[^>]*>/,"").gsub(/\s+/," ").gsub(/\&quote;/,"'").gsub(/\&[\#|\w]\w+\;/,"").gsub(/\#39\;/,"'"))
+      msg.speak((doc/"*/item/title").inner_html)
+
+    rescue Exception => e
+      msg.speak(e, "\n")
+    end
+  end
+end

data/plugins/schneier.rb

@@ -0,0 +1,28 @@
+require 'open-uri'
+require 'hpricot'
+
+class Schneier < CampfireBot::Plugin
+  BASE_URL   = 'http://geekz.co.uk/schneierfacts/'
+  
+  on_command 'schneier', :schneier
+  
+  def schneier(msg)
+    quote = case msg[:message].split(/\s+/)[0]
+    when 'latest'
+      fetch_quote(true)
+    when 'random'
+      fetch_quote
+    else
+      fetch_quote
+    end
+    msg.speak quote
+  rescue => e
+    msg.speak e
+  end
+  
+  private
+
+  def fetch_quote(latest = false)
+    CGI::unescapeHTML((Hpricot(open("#{BASE_URL}#{'fact/latest' if latest}"))).search('p .fact').html)
+  end
+end

data/plugins/seen.rb

@@ -0,0 +1,88 @@
+# Courtesy of joshwand (http://github.com/joshwand)
+class Seen < CampfireBot::Plugin
+  ACTIVITY_REGEXP = /^(.*)$/
+  SEEN_REGEXP = /([^\?]+)(?=\?)*/
+  
+  on_message Regexp.new("#{ACTIVITY_REGEXP.source}", Regexp::IGNORECASE), :update
+  on_command 'seen', :seen
+  on_command 'reload_seen', :reload
+  
+  def initialize
+    @data_file  = File.join(BOT_ROOT, 'tmp', "seen-#{BOT_ENVIRONMENT}.yml")
+    @seen       = YAML::load(File.read(@data_file)) rescue {}
+  end
+  
+  def update(msg)
+    left_room = (msg[:message] == "has left the room " ? true : false)
+    @seen[msg[:person]] = {:time => Time.now, :left => left_room}
+ 
+    File.open(@data_file, 'w') do |out|
+      YAML.dump(@seen, out)
+    end
+  end
+  
+  def seen(msg)
+    found = false
+    puts msg[:message]
+    puts msg[:message] =~ SEEN_REGEXP
+    
+    if !$1.nil?
+      first_name = $1.match("[A-Za-z]+")[0]
+      
+      @seen.each do |person, seenat|
+        if person.downcase.include?(first_name.downcase)
+          time_ago = time_ago_in_words(seenat[:time])
+          left = seenat[:left] ? "leaving the room " : ""
+          msg.speak("#{person} was last seen #{left}#{time_ago} ago")
+          found = true
+        end
+      end
+      
+      if !found
+        msg.speak("Sorry, I haven't seen #{first_name}.")
+      end
+      
+    end
+  end
+  
+  def reload(msg)
+    @seen = {}
+    msg.speak("ok, reloaded seen db")
+  end
+  
+  protected
+  
+  def time_ago_in_words(from_time, include_seconds = false)
+    distance_of_time_in_words(from_time, Time.now, include_seconds)
+  end
+  
+  def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false)
+    from_time = from_time.to_time if from_time.respond_to?(:to_time)
+    to_time = to_time.to_time if to_time.respond_to?(:to_time)
+    distance_in_minutes = (((to_time - from_time).abs)/60).round
+    distance_in_seconds = ((to_time - from_time).abs).round
+ 
+    case distance_in_minutes
+      when 0..1
+        return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
+        case distance_in_seconds
+          when 0..4   then 'less than 5 seconds'
+          when 5..9   then 'less than 10 seconds'
+          when 10..19 then 'less than 20 seconds'
+          when 20..39 then 'half a minute'
+          when 40..59 then 'less than a minute'
+          else             '1 minute'
+        end
+ 
+        when 2..44           then "#{distance_in_minutes} minutes"
+        when 45..89          then 'about 1 hour'
+        when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
+        when 1440..2879      then '1 day'
+        when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
+        when 43200..86399    then 'about 1 month'
+        when 86400..525599   then "#{(distance_in_minutes / 43200).round} months"
+        when 525600..1051199 then 'about 1 year'
+        else                      "over #{(distance_in_minutes / 525600).round} years"
+    end
+  end
+end

data/plugins/signal_filter.rb

@@ -0,0 +1,9 @@
+class SignalFilter < CampfireBot::Plugin
+  on_message /^\[.*?\]/i, :echo_signal
+  
+  def echo_signal(msg)
+    unless msg[:room] == bot.config['signal_target_room']
+      bot.rooms[bot.config['signal_target_room']].speak("#{msg[:person]} #{msg[:message]}")
+    end
+  end
+end

data/plugins/svn.rb

@@ -0,0 +1,167 @@
+require 'open-uri'
+require 'hpricot'
+require 'tempfile'
+
+class Svn < CampfireBot::Plugin
+  
+  at_interval 20.minutes, :check_svn
+  on_command 'svn', :checksvn_command
+  
+  
+  def initialize
+    # log "initializing... "
+    @data_file  = File.join(BOT_ROOT, 'tmp', "svn-#{BOT_ENVIRONMENT}-#{bot.config['room']}.yml")
+    @cached_revisions = YAML::load(File.read(@data_file)) rescue {}
+    @last_checked ||= 10.minutes.ago
+    @urls = bot.config['svn_urls']
+    @log = Logging.logger["CampfireBot::Plugin::Svn"]
+  end
+
+  # respond to checkjira command-- same as interval except we answer with 'no issues found' if 
+  def checksvn_command(msg)
+    msg.speak "no new commits since I last checked #{@lastlast} ago" if !check_svn(msg)
+  end
+  
+  def check_svn(msg)
+    
+    saw_a_commit = false
+    old_cache = Marshal::load(Marshal.dump(@cached_revisions)) # since ruby doesn't have deep copy
+    
+    @lastlast = time_ago_in_words(@last_checked)
+    commits = fetch_svn_urls
+    
+    commits.each do |commit|
+      # p commit
+      if new?(commit, old_cache)
+        saw_an_issue = true
+
+        @cached_revisions = update_cache(commit, @cached_revisions) 
+        flush_cache(@cached_revisions)
+    
+        messagetext = "#{commit[:author]} committed revision #{commit[:revision]} #{time_ago_in_words(commit[:date])} ago on #{commit[:url]}:\n"
+
+        messagetext += "\n#{commit[:message]}\n"
+        messagetext += "----\n"
+        commit[:paths].each do |path|
+          messagetext += path[:action] + " " + path[:path] + "\n"
+        end
+        
+        msg.paste(messagetext)
+        @log.info messagetext
+          
+      end
+    end
+
+    @last_checked = Time.now
+    @log.info "no new commits." if !saw_a_commit
+  
+    saw_a_commit
+  end
+  
+  protected
+  
+  # fetch jira url and return a list of commit Hashes
+  def fetch_svn_urls()
+    urls = bot.config['svn_urls']
+    commits = []
+    urls.each do |url|
+      begin
+        @log.info "checking #{url} for new commits..."
+        xmldata = `svn log --xml -v --limit 15 #{url}`
+        doc = REXML::Document.new(xmldata)
+      
+        doc.elements.inject('log/logentry', commits) do |commits, element|
+          commits.push({:url => url}.merge(parse_entry_info(element)))
+        end
+
+      rescue Exception => e
+        @log.error "error connecting to svn: #{e.message}"
+      end
+    end
+    return commits
+  end
+  
+  # extract commit hash from indivrevisionual xml element
+  def parse_entry_info(xml_element)
+    
+    revision =   xml_element.attributes['revision']
+    author =     xml_element.elements['author'].text
+    date =       DateTime.parse(xml_element.elements['date'].text)
+    message =    xml_element.elements['msg'].text
+    
+    paths = xml_element.elements.collect('paths/path') do |e|
+      {
+      :action => e.attributes['action'],
+      :path => e.text
+      }
+    end
+    
+    return {
+      :revision => revision,
+      :author => author,
+      :message => message,
+      :date => date,
+      :paths => paths
+    }
+  end
+  
+  # has this commit been seen before this run?
+  def new?(commit, old_cache)
+    !old_cache.key?(commit[:url]) or old_cache[commit[:url]] < commit[:revision].to_i
+  end
+  
+  # only update the cached highest revision if it is in fact the highest revision
+  def update_cache(commit, cache)
+    cache[commit[:url]] = commit[:revision].to_i if new?(commit, cache)
+    cache
+  end
+
+  # write the cache to disk
+  def flush_cache(cache)
+    File.open(@data_file, 'w') do |out|
+      YAML.dump(cache, out)
+    end
+  end
+  
+  
+  
+  # 
+  # time/utility functions
+  # 
+  
+  
+  def time_ago_in_words(from_time, include_seconds = false)
+    distance_of_time_in_words(from_time, Time.now, include_seconds)
+  end
+  
+  def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false)
+    from_time = from_time.to_time if from_time.respond_to?(:to_time)
+    to_time = to_time.to_time if to_time.respond_to?(:to_time)
+    distance_in_minutes = (((to_time - from_time).abs)/60).round
+    distance_in_seconds = ((to_time - from_time).abs).round
+
+    case distance_in_minutes
+      when 0..1
+        return (distance_in_minutes == 0) ? 'less than a minute' : '1 minute' unless include_seconds
+        case distance_in_seconds
+          when 0..4   then 'less than 5 seconds'
+          when 5..9   then 'less than 10 seconds'
+          when 10..19 then 'less than 20 seconds'
+          when 20..39 then 'half a minute'
+          when 40..59 then 'less than a minute'
+          else             '1 minute'
+        end
+
+        when 2..44           then "#{distance_in_minutes} minutes"
+        when 45..89          then 'about 1 hour'
+        when 90..1439        then "about #{(distance_in_minutes.to_f / 60.0).round} hours"
+        when 1440..2879      then '1 day'
+        when 2880..43199     then "#{(distance_in_minutes / 1440).round} days"
+        when 43200..86399    then 'about 1 month'
+        when 86400..525599   then "#{(distance_in_minutes / 43200).round} months"
+        when 525600..1051199 then 'about 1 year'
+        else                      "over #{(distance_in_minutes / 525600).round} years"
+    end
+  end
+  
+end