campfire-bot 0.0.1

data/plugins/beijing_tally.rb

@@ -0,0 +1,30 @@
+require 'open-uri'
+require 'hpricot'
+
+class BeijingTally < CampfireBot::Plugin
+  
+  on_command 'tally', :tally
+  
+  def tally(msg)
+    output    = "#{'Pos.'.rjust(6)} - #{'Country'.ljust(25)} -   G -   S -   B - Total\n"
+    rows      = ((Hpricot(open('http://results.beijing2008.cn/WRM/ENG/INF/GL/95A/GL0000000.shtml'))/'//table')[1]/'tr')[2..-1]
+    rows.each_with_index do |row, i|
+      cells   = row/'td'
+      output += "#{strip_tags_or_zero(cells[0].inner_html).rjust(6)} - " # position
+      output += "#{((i == rows.length - 1) ? '' : strip_tags_or_zero(cells[1].inner_html)).ljust(25)} - " # country
+      output += "#{strip_tags_or_zero(cells[-5].inner_html).rjust(3)} - " # gold
+      output += "#{strip_tags_or_zero(cells[-4].inner_html).rjust(3)} - " # silver
+      output += "#{strip_tags_or_zero(cells[-3].inner_html).rjust(3)} - " # bronze
+      output += "#{strip_tags_or_zero(cells[-2].inner_html).rjust(3)}\n"  # total
+    end
+    
+    msg.paste(output)
+  end
+  
+  private
+  
+  # Take away the HTML tags from the string and insert a '0' if it is empty
+  def strip_tags_or_zero(str)
+    (out = str.gsub(/<\/?[^>]*>/, "").strip).blank? ? '0' : out
+  end
+end

data/plugins/boop.rb

@@ -0,0 +1,127 @@
+# TODO
+#
+# - convert/filter out HTML entities like "
+# - add a callback to prime the chains when the bot is ready, and do this in a thread.
+
+class Boop < CampfireBot::Plugin
+  
+  # Markov chain implementation courtesy of http://blog.segment7.net/articles/2006/02/25/markov-chain
+  
+  on_message /.*/,                :listen
+  on_command 'speak',             :random_chatter
+  on_command 'prime_chains',      :load_transcripts
+  
+  def initialize
+    @phrases    = Hash.new { |hash, key| hash[key] = [] } # phrase => next-word possibilities
+    @word_count = 0
+  end
+
+  def listen(msg)
+    add_line(msg[:message])
+  end
+  
+  def random_chatter(msg)
+    puts "random_chatter"
+    msg.speak(generate_line)
+  end
+  
+  def focused_chatter(msg)
+    
+  end
+  
+  def load_transcripts(msg)
+    msg.speak("Filling my brain with transcripts...")
+    
+    puts "available transcripts - #{bot.room.available_transcripts.to_yaml}"
+    
+    bot.room.available_transcripts.to_a.each do |date|
+      puts "loading transcript #{date}"
+      
+      transcript = bot.room.transcript(date)
+      
+      transcript.each do |message|
+        puts "message: #{message[:message]}"
+        
+        filtered_text = strip_message(message)
+        
+        filtered_text.split("\n").each { |line| add_line(line) unless line.blank? }
+        filtered_text.split("\n").each { |line| puts "ACCEPTED: " + line unless line.blank? }
+        
+      end
+    end
+    
+    msg.speak("Primed!")
+  end
+  
+  private
+    
+  def add_line(line)
+    words        = line.scan(/\S+/)
+    @word_count += words.length
+    
+    words.each_with_index do |word, index|
+      phrase = words[index, phrase_length]             # current phrase
+      @phrases[phrase] << words[index + phrase_length] # next possibility
+    end
+  end
+  
+  def generate_line
+    # our seed phrase
+    # phrase = words[0, phrase_length]
+    phrase = [random_word]
+
+    output = []
+
+    @word_count.times do
+      # grab all possibilities for our state
+      options = @phrases[phrase]
+
+      # add the first word to our output and discard
+      output << phrase.shift
+
+      # select at random and add it to our phrase
+      phrase.push(options.rand)
+
+      # the last phrase of the input text will map to an empty array of
+      # possibilities so exit cleanly.
+      break if phrase.compact.empty? # all out of words
+    end
+
+    # return our output
+    output.join(' ')
+  end
+    
+  def random_word
+    @phrases.keys.rand.first
+  end
+  
+  # amount of state (order-k)
+  def phrase_length
+    1
+  end
+  
+  def strip_message(msg)
+    str = msg[:message].to_s
+    
+    return '' if str.blank?
+    
+    # return nothing if the line is a bot command
+    return '' if str[0..0] == '!' || str =~ Regexp.new("^#{bot.config['nickname']},", Regexp::IGNORECASE)
+    
+    # and get rid of the messages that are generated by the campfire system itself
+    return '' if str =~ /has (entered|left) the room/
+    
+    # keep the contents of the pastes, but strip out the 'view paste' link.
+    str.gsub!(/<a href=.*?>View paste<\/a>/, '')
+    
+    # also get rid of the stuff spoken by the bot
+    return '' if msg[:person] == bot.config['nickname']
+    
+    # now strip out all image tags completely
+    str.gsub!(/<img\s.*?\/>/, '')
+    
+    # and now strip out all other html tags, leaving their contents intact
+    str.gsub(/<\/?[^>]*>/, "")
+  end
+  
+end

data/plugins/bruce.rb

@@ -0,0 +1,15 @@
+require 'open-uri'
+require 'hpricot'
+require 'tempfile'
+
+class Bruce < CampfireBot::Plugin
+  on_command 'bruce', :fail
+  
+  def fail(msg)
+    # Scrape random fail
+    bruce = (Hpricot(open('http://www.schneierfacts.com/'))/'p.fact').first
+    msg.speak(CGI.unescapeHTML(bruce.inner_html))
+  rescue => e
+    msg.speak e
+  end
+end

data/plugins/bugzilla.rb

@@ -0,0 +1,198 @@
+require 'yaml'
+
+# Lookup bug titles and URLs when their number is mentioned or on command.
+#
+# You'll probably want to at least configure bugzilla_bug_url with the
+# URL to your bug tracking tool.  Put a '%s' where the bug ID should be
+# inserted.
+#
+# Several other options are available, including the interval in which
+# to avoid volunteering the same information, and whether to show the
+# url with the title.
+#
+# HTMLEntities will be used for better entity (–) decoding if
+# present, but is not required.
+#
+# Similarly, net/netrc will be used to supply HTTP Basic Auth
+# credentials, but only if it's available.
+#
+# While is designed to work with Bugzilla, it also works fine with:
+# * Debian bug tracking system
+# * KDE Bug tracking system
+# * Trac - if you configure to recognize "tickets" instead of "bugs"
+# * Redmine - if you configure to recognize "issues" instead of "bugs"
+class Bugzilla < CampfireBot::Plugin
+  on_command 'bug', :describe_command
+  # on_message registered below...
+
+  config_var :data_file, File.join(BOT_ROOT, 'tmp', 'bugzilla.yml')
+  config_var :min_period, 30.minutes
+  config_var :debug_enabled, false
+  config_var :bug_url, "https://bugzilla/show_bug.cgi?id=%s"
+  config_var :link_enabled, true
+  config_var :bug_id_pattern, '(?:[0-9]{3,6})'
+  config_var :bug_word_pattern, 'bugs?:?\s+'
+  config_var :mention_pattern,
+    '%2$s%1$s(?:(?:,\s*|,?\sand\s|,?\sor\s|\s+)%1$s)*'
+
+  attr_reader :bug_timestamps, :bug_id_regexp, :mention_regexp,
+    :use_htmlentities, :use_netrc
+
+  def initialize()
+    super
+    @bug_id_regexp = Regexp.new(bug_id_pattern, Regexp::IGNORECASE)
+    @mention_regexp = Regexp.new(sprintf(mention_pattern,
+                                         bug_id_pattern, bug_word_pattern),
+                      Regexp::IGNORECASE)
+    self.class.on_message mention_regexp, :describe_mention
+
+    @bug_timestamps = YAML::load(File.read(@data_file)) rescue {}
+    if link_enabled
+      require 'shorturl'
+    end
+
+    # 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
+    begin
+      require 'net/netrc'
+      @use_netrc = true
+    rescue LoadError
+      debug "Can't load 'net/netrc': HTTP Auth from .netrc will be unavailable"
+      require 'cgi'
+    end
+  end
+
+  def debug(spew)
+    $stderr.puts "#{self.class.name}: #{spew}" if debug_enabled
+  end
+
+  def describe_mention(msg)
+    debug "heard a mention"
+    match = msg[:message].match(mention_regexp)
+    describe_bugs msg, match.to_s, true
+  end
+
+  def describe_command(msg)
+    debug "received a command"
+    debug "msg[:message] = #{msg[:message].inspect}"
+    describe_bugs msg, msg[:message], false
+  end
+
+  protected
+
+  def describe_bugs(msg, text, check_timestamp)
+    summaries = text.to_s.scan(bug_id_regexp).collect { |bug|
+      debug "mentioned bug #{bug}"
+      now = Time.new
+      last_spoke = (bug_timestamps[msg[:room].name] ||= {})[bug]
+      if check_timestamp && !last_spoke.nil? && last_spoke > now - min_period
+        debug "keeping quiet, last spoke at #{last_spoke}"
+        nil
+      else
+        debug "fetching title for #{bug}"
+        url = sprintf(bug_url, bug)
+        html = http_fetch_body(url)
+        if !m = html.match("<title>([^<]+)</title>")
+          raise "no title for bug #{bug}!"
+        end
+        debug "fetched."
+        title = html_decode(m[1])
+        title += " (#{ShortURL.shorten(url)})" if link_enabled
+        bug_timestamps[msg[:room].name][bug] = now
+        title
+      end
+    }.reject { |s| s.nil? }
+    if !summaries.empty?
+      expire_timestamps
+      n = bug_timestamps.inject(0) { |sum, pair| sum + pair[1].size }
+      debug "Writing #{n} timestamps"
+      File.open(data_file, 'w') do |out|
+        YAML.dump(bug_timestamps, out)
+      end
+      # Speak the summaries all at once so they're more readable and
+      # not interleaved with someone else's speach
+      summaries.each { |s|
+        debug "sending response: #{s}"
+        msg.speak s
+      }
+    else
+      debug "nothing to say."
+    end
+  end
+
+  # Don't let the datafile or the in-memory list grow too
+  # large over long periods of time.  Remove entries that are
+  # well over min_period.
+  def expire_timestamps
+    debug "Expiring bug timestamps"
+    cutoff = Time.new - (2 * min_period)
+    recent = {}
+    bug_timestamps.each { |room, hash|
+      recent[room] = {}
+      hash.each { |bug, ts|
+        recent[room][bug] = ts if ts > cutoff
+      }
+      recent.delete(room) if recent[room].empty?
+    }
+    @bug_timestamps = recent
+  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
+
+  # Return the HTTPResponse
+  #
+  # Use SSL if necessary, and check .netrc for
+  # passwords.
+  def http_fetch(url)
+    uri = URI.parse url
+    http = Net::HTTP.new(uri.host, uri.port)
+
+    # Unfortunately the net/http(s) API can't seem to do this for us,
+    # even if we require net/https from the beginning (ruby 1.8)
+    if uri.scheme == "https"
+      require 'net/https'
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    res = http.start { |http|
+      req = Net::HTTP::Get.new uri.request_uri
+      cred = netrc_credentials uri.host
+      req.basic_auth *cred if cred
+      http.request req
+    }
+  end
+
+  # Returns only the document body
+  def http_fetch_body(url)
+    res = http_fetch(url)
+    case res
+    when Net::HTTPSuccess
+      res.body
+    else res.error!
+    end
+  end
+
+  # Returns [username, password] for the given host or nil
+  def netrc_credentials(host)
+    # Don't crash just b/c the gem is not installed
+    return nil if !use_netrc
+    obj = Net::Netrc.locate(host)
+    obj ? [obj.login, obj.password] : nil
+  end
+end

data/plugins/calvin.rb

@@ -0,0 +1,43 @@
+require 'open-uri'
+require 'hpricot'
+require 'tempfile'
+
+class Calvin < CampfireBot::Plugin
+  BASE_URL    = 'http://marcel-oehler.marcellosendos.ch/comics/ch/'
+  START_DATE  = Date.parse('1985-11-18')
+  END_DATE    = Date.parse('1995-12-31') # A sad day
+  
+  on_command 'calvin', :calvin
+  
+  def calvin(msg)    
+    comic = case msg[:message].split(/\s+/)[0]
+    when 'random'
+      fetch_random
+    when /d+/
+      fetch_comic(msg[:message].split(/\s+/)[0])
+    else
+      fetch_random
+    end
+    
+    msg.speak(comic)
+  end
+  
+  private
+  
+  def fetch_random
+    fetch_comic(rand(number_of_comics))
+  end
+  
+  def fetch_comic(id = nil)
+    date = id_to_date(id)
+    "#{BASE_URL}#{date.strftime('%Y')}/#{date.strftime('%m')}/#{date.strftime('%Y%m%d')}.gif"
+  end
+  
+  def id_to_date(id)
+    (START_DATE + id.days).to_date
+  end
+  
+  def number_of_comics
+    (END_DATE - START_DATE).to_i
+  end
+end

data/plugins/chuck.rb

@@ -0,0 +1,23 @@
+require 'open-uri'
+require 'hpricot'
+
+class Chuck < CampfireBot::Plugin
+  on_command 'chuck', :chuck
+  
+  def initialize
+    @log = Logging.logger["CampfireBot::Plugin::Chuck"]
+  end
+  
+  def chuck(msg)
+    url = "http://www.chucknorrisfacts.com/all-chuck-norris-facts?page=#{rand(172)+1}"
+    doc = Hpricot(open(url))
+    
+    facts = []
+    
+    (doc/".item-list a.createYourOwn").each do |a_tag|
+      facts << CGI.unescapeHTML(a_tag.inner_html)
+    end
+    
+    msg.speak(facts[rand(facts.size)])
+  end
+end

data/plugins/dilbert.rb

@@ -0,0 +1,51 @@
+require 'open-uri'
+require 'hpricot'
+require 'tempfile'
+
+
+class Dilbert < CampfireBot::Plugin
+  BASE_URL   = 'http://dilbert.com/'
+  START_DATE = Date.parse('1996-01-01')
+  
+  on_command 'dilbert', :dilbert
+  
+  def dilbert(msg)
+    comic = case msg[:message].split(/\s+/)[0]
+    when 'latest'
+      fetch_latest
+    when 'random'
+      fetch_random
+    when /d+/
+      fetch_comic(msg[:message].split(/\s+/)[1])
+    else
+      fetch_random
+    end
+    
+    msg.speak(BASE_URL + comic['src'])
+
+  end
+  
+  private
+  
+  def fetch_latest
+    fetch_comic
+  end
+  
+  def fetch_random
+    fetch_comic(rand(number_of_comics))
+  end
+  
+  def fetch_comic(id = nil)
+    # Rely on the comic being the last image on the page not nested
+    (Hpricot(open("#{BASE_URL}fast#{'/' + id_to_date(id) + '/' if id}"))/'//img').last
+  end
+  
+  def id_to_date(id)
+    (START_DATE + id.days).to_date.to_s(:db)
+  end
+  
+  def number_of_comics
+    (Date.today - START_DATE).to_i
+  end
+  
+end