sclemmer-robut 0.5.2

data/lib/robut/plugin/google_images.rb

@@ -0,0 +1,17 @@
+require 'google-search'
+
+# Responds with the first google image search result matching a query.
+class Robut::Plugin::GoogleImages
+  include Robut::Plugin
+
+  desc "image <query> - responds with the first image from a Google Images search for <query>"
+  match /^image (.*)/, :sent_to_me => true do |query|
+    image = Google::Search::Image.new(:query => query).first
+
+    if image
+      reply image.uri
+    else
+      reply "Couldn't find an image"
+    end
+  end
+end

data/lib/robut/plugin/help.rb

@@ -0,0 +1,16 @@
+# When asked for help, responds with a list of commands supported by
+# all loaded plugins
+class Robut::Plugin::Help
+  include Robut::Plugin
+
+  desc "help - displays this message"
+  match /^help$/, :sent_to_me => true do
+    reply("Supported commands:")
+    Robut::Plugin.plugins.each do |plugin|
+      plugin_instance = plugin.new(reply_to, private_sender)
+      Array(plugin_instance.usage).each do |command_usage|
+        reply(command_usage)
+      end
+    end
+  end
+end

data/lib/robut/plugin/later.rb

@@ -0,0 +1,81 @@
+# The Later plugin allows you to send messages/commands to robut based on
+# a time delay.  Like so:
+#
+#    @robut in 5 minutes lunch?
+#    @robut in 1 hr echo @justin wake up!
+#
+# @robut will respond effectively the same as he would if someone had told
+# him "lunch?" 5 minutes from now.  In the case of the Lunch plugin, he
+# would repond with a lunch suggestion.  The Later plugin works with all other
+# plugins as you follow this syntax:
+#
+#    @robut in <number> <mins|hrs|secs> [command]
+#
+# Where command is the message you want to send to @robut in the future.  For
+# the time denominations it also recognizes minute, minutes, hour, hours,
+# second, seconds.
+#
+class Robut::Plugin::Later
+  include Robut::Plugin
+
+  # Returns a description of how to use this plugin
+  def usage
+    "#{at_nick} in <number> <mins|hrs|secs> <command> - sends <command> to #{nick} after the specified interval"
+  end
+  
+  # Passes +message+ back through the plugin chain if we've been given
+  # a time to execute it later.
+  def handle(time, sender_nick, message)
+    if sent_to_me?(message)
+      phrase = words(message).join(' ')
+      if phrase =~ timer_regex
+        count = $1.to_i
+        scale = $2
+        future_message =  at_nick + ' ' + $3
+
+        sleep_time = count * scale_multiplier(scale)
+
+        if sleep_time >= 3600
+          reply "Too far into the future--ain't no body got (timeforthat)"
+          return
+        end
+
+        reply("Ok, see you in #{count} #{scale}")
+        connection = self.connection
+        threader do
+          sleep sleep_time
+          fake_message(Time.now, sender_nick, future_message)
+        end
+        return true
+      end
+    end
+  end
+
+  private
+
+  # A regex that detects a time.
+  def timer_regex
+    /in (.*) (sec|secs|second|seconds|min|mins|minute|minutes|hr|hrs|hour|hours) (.*)$/
+  end
+
+  # Takes a time scale (secs, mins, hours, etc.) and returns the
+  # factor to convert it into seconds.
+  def scale_multiplier(time_scale)
+    case time_scale
+    when /sec(s|ond|onds)?/
+      1
+    when /min(s|ute|utes)?/
+      60
+    when /(hr|hrs|hour|hours)/
+      60 * 60
+    end
+  end
+
+  # Asynchronously runs the given block.
+  def threader
+    Thread.new do
+      yield
+    end
+  end
+
+end

data/lib/robut/plugin/lunch.rb

@@ -0,0 +1,76 @@
+# Where should we go to lunch today?
+class Robut::Plugin::Lunch
+  include Robut::Plugin
+
+  # Returns a description of how to use this plugin
+  def usage
+    [
+      "lunch? / food? - #{nick} will suggest a place to go eat",
+      "#{at_nick} lunch places - lists all the lunch places #{nick} knows about",
+      "#{at_nick} new lunch place <place> - tells #{nick} about a new place to eat",
+      "#{at_nick} remove lunch place <place> - tells #{nick} not to suggest <place> anymore"
+    ]
+  end
+
+  # Replies with a random string selected from +places+.
+  def handle(time, sender_nick, message)
+    words = words(message)
+    phrase = words.join(' ')
+    # lunch?
+    if phrase =~ /^(lunch|food)\?$/i
+      if places.empty?
+        reply "I don't know about any lunch places"
+      else
+        $stderr.puts "*************************** -> #{sender_nick}"
+        reply choose_place(sender_nick) + "!"
+      end
+    # @robut lunch places
+    elsif phrase == "lunch places" && sent_to_me?(message)
+      if places.empty?
+        reply "I don't know about any lunch places"
+      else
+        reply places.join(', ')
+      end
+    # @robut new lunch place Green Leaf
+    elsif phrase =~ /new lunch place (.*)/i && sent_to_me?(message)
+      place = $1
+      new_place(place)
+      reply "Ok, I'll add \"#{place}\" to the the list of lunch places"
+    # @robut remove luynch place Green Leaf
+    elsif phrase =~ /remove lunch place (.*)/i && sent_to_me?(message)
+      place = $1
+      remove_place(place)
+      reply "I removed \"#{place}\" from the list of lunch places"
+    end
+  end
+
+  def choose_place(sender_nick)
+    excluded = sender_nick =~ /\bchu\b/i ? /\bchu\b/i : nil
+    # excluded = sender_nick =~ /\bclemmer\b/i ? /^[^g]/i : nil 
+    valid_places = places
+    valid_places = places.reject { |p| p =~ excluded } unless excluded.nil?
+    return valid_places[rand(valid_places.length)]
+  end
+
+  # Stores +place+ as a new lunch place.
+  def new_place(place)
+    store["lunch_places"] ||= []
+    store["lunch_places"] = (store["lunch_places"] + Array(place)).uniq
+  end
+
+  # Removes +place+ from the list of lunch places.
+  def remove_place(place)
+    store["lunch_places"] ||= []
+    store["lunch_places"] = store["lunch_places"] - Array(place)
+  end
+
+  # Returns the list of lunch places we know about.
+  def places
+    store["lunch_places"] ||= []
+  end
+
+  # Sets the list of lunch places to +v+
+  def places=(v)
+    store["lunch_places"] = v
+  end
+end

data/lib/robut/plugin/meme.rb

@@ -0,0 +1,32 @@
+require 'cgi'
+
+# A simple plugin that wraps memecaptain.
+# This plugin is activated when robut is sent a message starting
+# with the name of a meme. The list of generators can be discovered
+# by running
+#
+#   @robut meme list
+#
+# from the command line. Example:
+#
+#   @robut meme all_the_things write; all the plugins
+#
+# Send message to the specified meme generator. If the meme requires
+# more than one line of text, lines should be separated with a semicolon.
+class Robut::Plugin::Meme
+  include Robut::Plugin
+
+  desc "meme <meme> <line1>;<line2> - responds with a link to a generated <meme> image using <line1> and <line2>.  " +
+    "See http://memecaptain.com/ for a list of memes.  You can also pass a link to your own image as the meme."
+  match /^meme (\S+) (.*)$/, :sent_to_me => true do |meme, text|
+    if meme.include?("://")
+      url = meme
+    else
+      url = "http://memecaptain.com/#{meme}.jpg"
+    end
+    line1, line2 = text.split(';').map { |line| CGI.escape(line.strip)}
+    meme_url = "http://memecaptain.com/i?u=#{url}&tt=#{line1}"
+    meme_url += "&tb=#{line2}" if line2
+    reply(meme_url)
+  end
+end

data/lib/robut/plugin/pick.rb

@@ -0,0 +1,18 @@
+require 'calc'
+
+# Let fate decide!
+class Robut::Plugin::Pick
+  include Robut::Plugin
+
+  desc "pick <a>, <b>, <c>, ...  - randomly selects one of the options"
+  match /^pick (.*)/, :sent_to_me => true do |message|
+    options = message.split(',').map { |s| s.strip }
+    rsp = options[random(options.length)]
+    reply("And the winner is... #{rsp}") if rsp
+  end
+
+  def random(c)
+    rand(c)
+  end
+
+end

data/lib/robut/plugin/ping.rb

@@ -0,0 +1,9 @@
+# A simple plugin that replies with "pong" when messaged with ping
+class Robut::Plugin::Ping
+  include Robut::Plugin
+
+  desc "ping - responds 'pong'"
+  match /^ping$/, :sent_to_me => true do
+    reply("pong")
+  end
+end

data/lib/robut/plugin/quips.rb

@@ -0,0 +1,60 @@
+# Stores quotes and replies with a random stored quote.
+class Robut::Plugin::Quips
+  include Robut::Plugin
+
+  desc "add quip <text> - adds a quip to the quip database"
+  match /^add quip (.+)/, :sent_to_me => true do |new_quip|
+    if add_quip(new_quip)
+      reply "I added the quip to the quip database"
+    else
+      reply "I didn't add the quip, since it was already added"
+    end
+  end
+
+  desc "remove quip <text> - removes a quip from the quip database"
+  match /^remove quip (.+)/, :sent_to_me => true do |quip|
+    if remove_quip(quip)
+      reply "I removed the quip from the quip database"
+    else
+      reply "I couldn't remove the quip, since it wasn't in the quip database"
+    end
+  end
+
+  desc "quip - returns a random quip"
+  match /^quip$/, :sent_to_me => true do
+    quip = random_quip
+    if quip
+      reply quip
+    else
+      reply "I don't know any quips"
+    end
+  end
+
+  # The list of quips stored in the quip database
+  def quips
+    # I'd love to use a set here, but it doesn't serialize right to yaml
+    store["quips"] ||= []
+  end
+
+  # Update the list of quips stored in the quip database
+  def quips=(new_quips)
+    # I'd love to use a set here, but it doesn't serialize right to yaml
+    store["quips"] = new_quips
+  end
+
+  # Adds +quip+ to the quip database
+  def add_quip(quip)
+    self.quips = (quips + Array(quip)) unless quips.include?(quip)
+  end
+
+  # Removes +quip+ from the quip database
+  def remove_quip(quip)
+    self.quips = (quips - Array(quip)) if quips.include?(quip)
+  end
+
+  # Returns a random quip
+  def random_quip
+    quips[rand(quips.length)] unless quips.empty?
+  end
+
+end

data/lib/robut/plugin/say.rb

@@ -0,0 +1,23 @@
+# This is a simple plugin the envokes the "say" command on whatever is passed
+# Example:
+#
+#    @robut say that was awesome!
+#
+# *Requires that the "say" command is installed and in the path
+#
+class Robut::Plugin::Say
+  include Robut::Plugin
+
+  desc "say <words> - uses Mac OS X's 'say' command to speak <words>"
+  match "^say (.*)$", :sent_to_me => true do |phrase|
+    phrase = clean(phrase)
+    system("say #{phrase}")
+  end
+
+  private
+
+  def clean(str)
+    str.gsub("'", "").gsub(/[^A-Za-z0-9\s]+/, " ").gsub(/\s+/, ' ').strip
+  end
+
+end

data/lib/robut/plugin/sayings.rb

@@ -0,0 +1,37 @@
+# A simple regex => response plugin.
+class Robut::Plugin::Sayings
+  include Robut::Plugin
+
+  class << self
+    # A list of arrays. The first element is a regex, the second is
+    # the reply sent if the regex matches. After the first match, we
+    # don't try to match any other sayings. Configuration looks like the following:
+    #
+    #   [["you're the worst", "I know."], ["sucks", "You know something, you suck!" ]]
+    #
+    # All regex matches are case-insensitive.
+    attr_accessor :sayings
+  end
+  self.sayings = []
+
+  # Returns a description of how to use this plugin
+  def usage
+    "#{at_nick} <words> - if <words> matches a regular expression defined in the Chatfile, responds with the specified response"
+  end
+
+  # For each element in sayings, creates a regex out of the first
+  # element, tries to match +message+ to it, and replies with the
+  # second element if it found a match. Robut::Plugin::Sayings will
+  # only respond once to each message, with the first match.
+  def handle(time, sender_nick, message)
+    # Tries to respond to any message sent to robut.
+    if sent_to_me?(message)
+      self.class.sayings.each do |saying|
+        if words(message).join(' ').match(/#{saying.first}/i)
+          reply(saying.last)
+          return
+        end
+      end
+    end
+  end
+end

data/lib/robut/plugin/stock.rb

@@ -0,0 +1,45 @@
+begin
+  require 'yahoofinance' # require yahoofinance gem
+rescue LoadError
+  puts "You must install the yahoofinance gem in order to use the Stock plugin"
+  raise $!
+end
+
+class Robut::Plugin::Stock
+  include Robut::Plugin
+
+  desc "stock <symbol> - Returns a stock data from Yahoo Finance"
+  match /^stock (.*)/, :sent_to_me => true do |phrase|
+    stock_data = get_stock_data(format_stock_symbols(phrase))
+    reply format_reply(stock_data)
+  end
+
+  private
+
+  def format_reply(stock_data)
+    r = []
+    stock_data.keys.sort.each do |sym|
+      sd = stock_data[sym]
+      r << "#{sym}: #{format_number(sd.changePoints)} / #{format_number(sd.changePercent)}%,\tbid: #{pad_number(sd.bid)},\task: #{pad_number(sd.ask)},\tprevious close: #{pad_number(sd.previousClose)}"
+    end
+    r.join("\n")
+  end
+
+  def format_number(n)
+    n > 0 ? "+" + pad_number(n) : pad_number(n)
+  end
+
+  def pad_number(n)
+    sprintf("%.2f", n)
+  end
+
+  def format_stock_symbols(phrase)
+    phrase.downcase.split(/[\s,;]+/).join(',')
+  end
+
+  def get_stock_data(symbols)
+    YahooFinance::get_quotes(YahooFinance::StandardQuote, symbols)
+  end
+
+
+end

data/lib/robut/plugin/twss.rb

@@ -0,0 +1,19 @@
+require 'twss-classifier'
+
+# A simple plugin that feeds everything said in the room through the
+# twss gem. Requires the 'twss' gem, obviously.
+class Robut::Plugin::TWSS
+  include Robut::Plugin
+
+  # Returns a description of how to use this plugin
+  def usage
+    "<words> - responds with \"That's what she said!\" if #{nick} thinks <words> is a valid TWSS"
+  end
+
+  # Responds "That's what she said!" if the TWSS gem returns true for
+  # +message+. Strips out any reference to our nick in +message+
+  # before it stuffs +message+ into the gem.
+  def handle(time, sender_nick, message)
+    reply("That's what she said!") if TWSSClassifier.is_twss?(words(message).join(" "))
+  end
+end

data/lib/robut/plugin/weather.rb

@@ -0,0 +1,126 @@
+require 'open-uri'
+require 'nokogiri'
+
+# What's the current weather forecast?
+class Robut::Plugin::Weather
+  include Robut::Plugin
+
+  class << self
+    attr_accessor :default_location
+  end
+
+  # Returns a description of how to use this plugin
+  def usage
+    [
+      "#{at_nick} weather - returns the weather in the default location for today",
+      "#{at_nick} weather tomorrow - returns the weather in the default location for tomorrow",
+      "#{at_nick} weather <location> - returns the weather for <location> today",
+      "#{at_nick} weather <location> Tuesday - returns the weather for <location> Tuesday"
+    ]
+  end
+  
+  def handle(time, sender_nick, message)
+    # ignore messages that don't end in ?
+    return unless message[message.length - 1, 1] == "?"
+    message = message[0..message.length - 2]
+
+    words = words(message)
+    i = words.index("weather")
+
+    # ignore messages that don't have "weather" in them
+    return if i.nil?
+
+    location = i.zero? ? self.class.default_location : words[0..i-1].join(" ")
+    if location.nil?
+      reply "I don't have a default location!"
+      return
+    end
+
+    day_of_week = nil
+    day_string = words[i+1..-1].join(" ").downcase
+    if day_string != ""
+      day_of_week = parse_day(day_string)
+      if day_of_week.nil?
+        reply "I don't recognize the date: \"#{day_string}\""
+        return
+      end
+    end
+
+    if bad_location?(location)
+      reply "I don't recognize the location: \"#{location}\""
+      return
+    end
+
+    if day_of_week
+      reply forecast(location, day_of_week)
+    else
+      reply current_conditions(location)
+    end
+  end
+
+  def parse_day(day)
+    day_map = {
+      "monday"    =>  "Mon",
+      "mon"       =>  "Mon",
+      "tuesday"   =>  "Tue",
+      "tue"       =>  "Tue",
+      "tues"      =>  "Tue",
+      "wed"       =>  "Wed",
+      "wednesday" =>  "Wed",
+      "thurs"     =>  "Thu",
+      "thu"       =>  "Thu",
+      "thursday"  =>  "Thu",
+      "friday"    =>  "Fri",
+      "fri"       =>  "Fri",
+      "saturday"  =>  "Sat",
+      "sat"       =>  "Sat",
+      "sunday"    =>  "Sun",
+      "sun"       =>  "Sun",
+    }
+    if day_map.has_key?(day)
+      return day_map[day]
+    end
+
+    if day == "tomorrow"
+      return (Time.now + 60*60*24).strftime("%a")
+    end
+
+    if day == "today"
+      return Time.now.strftime("%a")
+    end
+  end
+
+  def current_conditions(location)
+    doc = weather_data(location)
+    condition = doc.search("current_conditions condition").first["data"]
+    temperature = doc.search("current_conditions temp_f").first["data"]
+    normalized_location = doc.search("forecast_information city").first["data"]
+    "Weather for #{normalized_location}: #{condition}, #{temperature}F"
+  end
+
+  def forecast(location, day_of_week)
+    doc = weather_data(location)
+    forecast = doc.search("forecast_conditions").detect{|el| c = el.children.detect{|c| c.name == "day_of_week"}; c && c["data"] == day_of_week}
+    return "Can't find a forecast for #{day_of_week}" if forecast.nil?
+
+    condition = forecast.children.detect{|c| c.name == "condition"}["data"]
+    high = forecast.children.detect{|c| c.name == "high"}["data"]
+    low = forecast.children.detect{|c| c.name == "low"}["data"]
+    normalized_location = doc.search("forecast_information city").first["data"]
+    "Forecast for #{normalized_location} on #{day_of_week}: #{condition}, High: #{high}F, Low: #{low}F"
+  end
+
+  def weather_data(location = "")
+    @weather_data ||= {}
+    @weather_data[location] ||= begin
+      url = "http://www.google.com/ig/api?weather=#{URI.escape(location)}"
+      Nokogiri::XML(open(url))
+    end
+    @weather_data[location]
+  end
+
+  def bad_location?(location = "")
+    weather_data(location).search("forecast_information").empty?
+  end
+
+end