robut 0.2.1 → 0.3.0

data/.gitignore

@@ -3,4 +3,6 @@
 Gemfile.lock
 pkg/*
 doc/*
-coverage/*
+coverage/*
+*.swp
+.DS_Store

data/Gemfile

@@ -6,6 +6,8 @@ gem 'rake'
 
 group :test do
   gem 'simplecov'
+  gem 'webmock'
+  gem 'time-warp'
 end
 
 group :plugin do
@@ -14,4 +16,5 @@ group :plugin do
   gem 'rdio', '0.0.91' # .92 is horked
   gem 'sinatra'
   gem 'meme_generator'
-end
+  gem 'nokogiri'
+end

data/README.rdoc

@@ -20,10 +20,10 @@ Others listen to everything, and don't require an @reply.
 
 Some of the included plugins require extra gems to be installed:
 
-[Robut::Plugin::TWSS] requires the <tt>twss</tt> gem
-[Robut::Plugin::Meme] requires the <tt>meme_generator</tt> gem
-[Robut::Plugin::Calc] requires the <tt>calc</tt> gem
-[Robut::Plugin::Rdio] requires the <tt>rdio</tt> and <tt>sinatra</tt> gems
+[Robut::Plugin::TWSS] requires the <tt>twss</tt> gem.
+[Robut::Plugin::Calc] requires the <tt>calc</tt> gem.
+[Robut::Plugin::Rdio] requires the <tt>rdio</tt> and <tt>sinatra</tt> gems.
+[Robut::Plugin::Weather] requires the <tt>nokogiri</tt> gem.
 
 == The Chatfile
 
@@ -88,35 +88,94 @@ This block usually goes at the end of the Chatfile.
 
 Robut includes a few plugins that we've found useful:
 
-[Robut::Plugin::Calc] a simple calculator. <br /> <br /> Example: <tt>@robut calc 1 + 1 # => 2</tt>
-[Robut::Plugin::Lunch] a random decider for lunch locations. <br /> <br /> Example: <tt>@robut lunch? # => "Banh Mi!"</tt>
-[Robut::Plugin::Meme] an interface to memegenerator.net. <br /> <br /> Example: <tt>@robut meme Y_U_NO FIX THE BUILD?</tt>
-[Robut::Plugin::Sayings] a simple regex listener and responder. <br /> <br /> Example: <tt>You're the worst robot ever, @robut. # => I know. </tt>
-[Robut::Plugin::TWSS] an interface to the TWSS gem. Listens to anything said in the chat room and responds "That's what she said!" where appropriate. <br /> <br /> Example: <tt>well hurry up, you're not going fast enough # => "That's what she said!" </tt>
-[Robut::Plugin::Echo] echo back whatever it gets. <br /> <br /> Example: <tt>@robut echo hello word</tt>
-[Robut::Plugin::Say] invokes the "say" command (text-to-speech). <br /> <br /> Example: <tt>@robut say this rocks</tt>
-[Robut::Plugin::Ping] responds with "pong". <br /> <br /> Example: <tt>@robut ping</tt>
-[Robut::Plugin::Later] performs the given command after waiting an arbitrary amount of time. <br /> <br /> Example: <tt>@robut in 5 minutes echo @justin wake up!</tt>
-[Robut::Plugin::Rdio] uses the Rdio[http://www.rdio.com] API and a simple web server to queue and play songs on Rdio. <br /> <br /> Example: <tt>@robut play ok computer</tt>
+[Robut::Plugin::Calc] a simple calculator.
+
+  @robut calc 1 + 1 # => 2
+
+
+[Robut::Plugin::Lunch] a random decider for lunch locations.
+
+  @robut lunch? # => "Banh Mi!"
+
+
+[Robut::Plugin::Meme] an interface to memecaptain. 
+
+  @robut meme all_the_things drink; all the beer
+
+
+[Robut::Plugin::Sayings] a simple regex listener and responder. 
+
+  You're the worst robot ever, @robut. # => I know.
+
+[Robut::Plugin::TWSS] an interface to the TWSS gem. Listens to anything said in the chat room and responds "That's what she said!" where appropriate. 
+
+  well hurry up, you're not going fast enough # => "That's what she said!"
+
+
+[Robut::Plugin::Echo] echo back whatever it gets.
+
+  @robut echo hello world # => "hello world"
+
+
+[Robut::Plugin::Say] invokes the "say" command (text-to-speech). 
+
+  @robut say this rocks # (make sure robut is running on a machine with speakers :)
+
+
+[Robut::Plugin::Ping] responds with "pong". 
+
+  @robut ping # => "pong"
+
+
+[Robut::Plugin::Later] performs the given command after waiting an arbitrary amount of time.
+
+  @robut in 5 minutes echo @justin wake up! # => (5 minutes later) "@justin wake up!"
+
+
+[Robut::Plugin::Rdio] uses the Rdio[http://www.rdio.com] API and a simple web server to queue and play songs on Rdio.
+
+  @robut play ok computer
+
+
+[Robut::Plugin::Weather] uses Google Weather to fetch for the weather for a given location and day.
+
+  @robut seattle weather saturday? # => "Forecast for Seattle, WA on Sat: Sunny, High: 77F, Low: 55F"
+
+[Robut::Plugin::Alias] creates aliases to other robut commands.
+
+  @robut alias "cowboy" "@robut play bon jovi wanted dead or alive" # Cuz somtimes you need it.
+  @robut alias w weather? # less typing for common stuff
+
+[Robut::Plugin::Help] lists usage for all the plugins loaded into robut
+
+  @robut help # => command usage
 
 == Writing custom plugins
 
-You can supply your own plugins to Robut. To create a plugin, subclass
-Robut::Plugin::Base and implement the <tt>handle(time, sender_nick,
-message)</tt> to perform any plugin-specific logic.
+You can supply your own plugins to Robut. To create a plugin, include
+the Robut::Plugin module and implement the <tt>handle(time,
+sender_nick, message)</tt> to perform any plugin-specific logic.
 
-Robut::Plugin::Base provides a few helper methods that are documented
+Robut::Plugin provides a few helper methods that are documented
 in its class definition.
 
 == Contributing
 
-Once you've made your great commits:
+To test your changes:
+
+1. Install [Bundler](http://gembundler.com/)
+2. Run `bundle install`
+3. Make your changes and run `bundle exec ruby -Ilib bin/robut ~/MyTestingChatfile`
+4. Add tests and verify by running `bundle exec rake test`
+
+Once your changes are ready:
 
 1. Fork robut
-2. Create a topic branch - git checkout -b my_branch
-3. Push to your branch - git push origin my_branch
-4. Send me a pull request
-5. That's it!
+2. Create a topic branch: `git checkout -b my_branch`
+3. Commit your changes
+4. Push to your branch: `git push origin my_branch`
+5. Send me a pull request
+6. That's it!
 
 == Todo
 

data/lib/rexml_patches.rb

@@ -0,0 +1,26 @@
+# Encoding patch, stolen from https://github.com/ln/xmpp4r/issues/3#issuecomment-1739952
+require 'socket'
+class TCPSocket
+  def external_encoding
+    Encoding::BINARY
+  end
+end
+
+require 'rexml/source'
+class REXML::IOSource
+  alias_method :encoding_assign, :encoding=
+  def encoding=(value)
+    encoding_assign(value) if value
+  end
+end
+
+begin
+  # OpenSSL is optional and can be missing
+  require 'openssl'
+  class OpenSSL::SSL::SSLSocket
+    def external_encoding
+      Encoding::BINARY
+    end
+  end
+rescue
+end

data/lib/robut/connection.rb

@@ -3,10 +3,15 @@ require 'xmpp4r/muc/helper/simplemucclient'
 require 'xmpp4r/roster/helper/roster'
 require 'ostruct'
 
+if defined?(Encoding)
+  # Monkey-patch an incompatibility between ejabberd and rexml
+  require 'rexml_patches'
+end
+
 # Handles opening a connection to the HipChat server, and feeds all
 # messages through our Robut::Plugin list.
 class Robut::Connection
-  
+
   # The configuration used by the Robut connection.
   #
   # Parameters:
@@ -53,12 +58,12 @@ class Robut::Connection
   def config=(config)
     @config = config.kind_of?(Hash) ? OpenStruct.new(config) : config
   end
-  
+
   # Initializes the connection. If no +config+ is passed, it defaults
   # to the class_level +config+ instance variable.
   def initialize(_config = nil)
     self.config = _config || self.class.config
-    
+
     self.client = Jabber::Client.new(self.config.jid)
     self.muc = Jabber::MUC::SimpleMUCClient.new(client)
     self.store = self.config.store || Robut::Storage::HashStore # default to in-memory store only
@@ -68,7 +73,7 @@ class Robut::Connection
       Jabber.debug = true
     end
   end
-  
+
   # Send +message+ to the room we're currently connected to, or
   # directly to the person referenced by +to+. +to+ can be either a
   # jid or the string name of the person.
@@ -77,7 +82,7 @@ class Robut::Connection
       unless to.kind_of?(Jabber::JID)
         to = find_jid_by_name(to)
       end
-      
+
       msg = Jabber::Message.new(to || muc.room, message)
       msg.type = :chat
       client.send(msg)
@@ -86,8 +91,12 @@ class Robut::Connection
     end
   end
 
-  # Sends the chat message +message+ through +plugins+. 
+  # Sends the chat message +message+ through +plugins+.
   def handle_message(plugins, time, nick, message)
+    # ignore all messages sent by robut. If you really want robut to
+    # reply to itself, you can use +fake_message+.
+    return if nick == config.nick
+    
     plugins.each do |plugin|
       begin
         rsp = plugin.handle(time, nick, message)
@@ -122,7 +131,7 @@ class Robut::Connection
     # Add the callback from direct messages. Turns out the
     # on_private_message callback doesn't do what it sounds like, so I
     # have to go a little deeper into xmpp4r to get this working.
-    client.add_message_callback(200, self) { |message|
+    client.add_message_callback(200, self) do |message|
       if !muc.from_room?(message.from) && message.type == :chat && message.body
         time = Time.now # TODO: get real timestamp? Doesn't seem like
                         # jabber gives it to us
@@ -133,8 +142,8 @@ class Robut::Connection
       else
         false
       end
-    }
-        
+    end
+
     muc.join(config.room + '/' + config.nick)
 
     trap_signals
@@ -142,7 +151,7 @@ class Robut::Connection
   end
 
   private
-  
+
   # Since we're entering an infinite loop, we have to trap TERM and
   # INT. If something like the Rdio plugin has started a server that
   # has already trapped those signals, we want to run those signal
@@ -153,7 +162,7 @@ class Robut::Connection
       old_signal_callbacks[signal].call if old_signal_callbacks[signal]
       exit
     end
-    
+
     [:INT, :TERM].each do |sig|
       old_signal_callbacks[sig] = trap(sig) { signal_callback.call(sig) }
     end

data/lib/robut/plugin.rb

@@ -1,8 +1,7 @@
 # Robut plugins implement a simple interface to listen for messages
-# and optionally respond to them. All plugins inherit from
-# Robut::Plugin::Base.
+# and optionally respond to them. All plugins include the Robut::Plugin
+# module.
 module Robut::Plugin
-  autoload :Base, 'robut/plugin/base'
 
   class << self
     # A list of all available plugin classes. When you require a new
@@ -13,4 +12,90 @@ module Robut::Plugin
 
   self.plugins = []
 
+  # A reference to the connection attached to this instance of the
+  # plugin. This is mostly used to communicate back to the server.
+  attr_accessor :connection
+
+  # If we are handling a private message, holds a reference to the
+  # sender of the message. +nil+ if the message was sent to the entire
+  # room.
+  attr_accessor :private_sender
+
+  # Creates a new instance of this plugin that references the
+  # specified connection.
+  def initialize(connection, private_sender = nil)
+    self.connection = connection
+    self.private_sender = private_sender
+  end
+
+  # Send +message+ back to the HipChat server. If +to+ == +:room+,
+  # replies to the room. If +to+ == nil, responds in the manner the
+  # original message was sent. Otherwise, PMs the message to +to+.
+  def reply(message, to = nil)
+    if to == :room
+      connection.reply(message, nil)
+    else
+      connection.reply(message, to || private_sender)
+    end
+  end
+
+  # An ordered list of all words in the message with any reference to
+  # the bot's nick stripped out. If +command+ is passed in, it is also
+  # stripped out. This is useful to separate the 'parameters' from the
+  # 'commands' in a message.
+  def words(message, command = nil)
+    reply = at_nick
+    command = command.downcase if command
+    message.split.reject {|word| word.downcase == reply || word.downcase == command }
+  end
+
+  # Removes the first word in message if it is a reference to the bot's nick
+  # Given "@robut do this thing", Returns "do this thing"
+  def without_nick(message)
+    possible_nick, command = message.split(' ', 2)
+    if possible_nick == at_nick
+      command
+    else
+      message
+    end
+  end
+
+  # The bot's nickname, for @-replies.
+  def nick
+    connection.config.nick.split.first
+  end
+
+  # #nick with the @-symbol prepended
+  def at_nick
+    "@#{nick.downcase}"
+  end
+
+  # Was +message+ sent to Robut as an @reply?
+  def sent_to_me?(message)
+    message =~ /(^|\s)@#{nick}(\s|$)/i
+  end
+
+  # Do whatever you need to do to handle this message.
+  # If you want to stop the plugin execution chain, return +true+ from this
+  # method.  Plugins are handled in the order that they appear in
+  # Robut::Plugin.plugins
+  def handle(time, sender_nick, message)
+    raise NotImplementedError, "Implement me in #{self.class.name}!"
+  end
+
+  # Returns a list of messages describing the commands this plugin
+  # handles.
+  def usage
+  end
+
+  def fake_message(time, sender_nick, msg)
+    # TODO: ensure this connection is threadsafe
+    plugins = Robut::Plugin.plugins.map { |p| p.new(connection, private_sender) }
+    connection.handle_message(plugins, time, sender_nick, msg)
+  end
+
+  # Accessor for the store instance
+  def store
+    connection.store
+  end
 end

data/lib/robut/plugin/alias.rb

@@ -0,0 +1,109 @@
+require 'shellwords'
+
+# Alias robut commands:
+#
+# @robut alias "something" "some long message"
+#
+# Later if @robut receives the message "@robut something" he will
+# repond as if he received "@robut some long message"
+#
+#
+# Valid use:
+#
+#   @robut alias this "something long"
+#   @robut alias "this thing" "something long"
+#   @robut alias this something_long
+#
+# Listing all aliases
+#
+#   @robut aliases
+#
+# Removing aliases
+#
+#   @robut remove alias "this alias"
+#   @robut remove alias this
+#   @robut remove clear aliases # removes everything
+#
+# Note: you probably want the Alias plugin as one of the first things
+# in the plugin array (since plugins are executed in order).
+class Robut::Plugin::Alias
+  include Robut::Plugin
+
+  # Returns a description of how to use this plugin
+  def usage
+    [
+      "#{at_nick} alias <words> <expansion> - when #{nick} sees <words>, pretend it saw <expansion> instead",
+      "#{at_nick} aliases - show all aliases",
+      "#{at_nick} remove alias <words> - remove <words> as an alias",
+      "#{at_nick} clear aliases - remove all aliases"
+    ]
+  end
+
+  # Perform the calculation specified in +message+, and send the
+  # result back.
+  def handle(time, sender_nick, message)
+    if new_message = get_alias(message)
+      # Apply the alias
+      fake_message Time.now, sender_nick, new_message
+    elsif sent_to_me?(message)
+      message = without_nick message
+      if message =~ /^remove alias (.*)/
+        # Remove the alias
+        key = parse_alias_key($1)
+        remove_alias key
+        return true
+      elsif message =~ /^clear aliases$/
+        self.aliases = {}
+        return true
+      elsif message =~ /^alias (.*)/
+        # Create a new alias
+        message = $1
+        key, value = parse_alias message
+        store_alias key, value
+        return true # hault plugin execution chain
+      elsif words(message).first == 'aliases'
+        # List all aliases
+        m, a = [], aliases # create reference to avoid going to the store every time
+        a.keys.sort.each { |key| m << "#{key} => #{a[key]}" }
+        reply m.join("\n")
+        return true
+      end
+    end
+  end
+
+  # Given a message, returns what it is aliased to (or nil)
+  def get_alias(msg)
+    (store['aliases'] || {})[msg]
+  end
+
+  def store_alias(key, value)
+    aliases[key] = value
+    store['aliases'] = aliases
+  end
+
+  def remove_alias(key)
+    new_aliases = aliases
+    new_aliases.delete(key)
+    store['aliases'] = new_aliases
+  end
+
+  def aliases
+    store['aliases'] ||= {}
+  end
+
+  def aliases=(v)
+    store['aliases'] = v
+  end
+
+  # Returns alias and command
+  def parse_alias(str)
+    r = Shellwords.shellwords str
+    return r[0], r[1] if r.length == 2
+    return r[0], r[1..-1].join(' ')
+  end
+
+  def parse_alias_key(str)
+    Shellwords.shellwords(str).join(' ')
+  end
+
+end