sclemmer-robut 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 76b46a0e0add81cb61e96c4325b483eb30b9aa26
+  data.tar.gz: c1e8ab8df7ed607a16ecbd71492fbd621b5e9d51
+SHA512:
+  metadata.gz: 0dec9cb846b2a9c9d52a559012de494719fa403dcbfa3aca3e0519d229e099325b3698f9ae4b39665b2b8391bf1e6a4e060c5e04db0bc60f585ac0e5026c4764
+  data.tar.gz: 071bf604bc1b899acbc8c9b2c25a6e63525cb6fd47526da1681a2b8b0fe68a392089515ff85df31eb729299fc981ede1a7361a2e0ad84e9db34a02c8e37bea8c

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+pkg/*
+doc/*
+coverage/*
+*.swp
+.DS_Store

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  # - 1.8.7
+  - 1.9.3
+  - 2.0
+  # - jruby-18mode # JRuby in 1.8 mode
+  # - jruby-19mode # JRuby in 1.9 mode
+  # - rbx-18mode
+  # - rbx-19mode # currently in active development, may or may not work for your project
+# uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,21 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem 'rake'
+
+group :test do
+  gem 'simplecov'
+  gem 'webmock'
+  gem 'time-warp'
+  gem 'mocha'
+  gem 'rack-test'
+  gem 'minitest'
+end
+
+group :plugin do
+  gem 'calc'
+  gem 'twss-classifier'
+  gem 'meme_generator'
+  gem 'nokogiri'
+end

data/Gemfile.lock

@@ -0,0 +1,65 @@
+PATH
+  remote: .
+  specs:
+    sclemmer-robut (0.5.2)
+      sinatra (~> 1.3)
+      xmpp4r (~> 0.5.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    calc (1.0.0)
+    crack (0.4.1)
+      safe_yaml (~> 0.9.0)
+    docile (1.1.1)
+    meme_generator (1.9)
+      nokogiri (~> 1.4)
+    metaclass (0.0.1)
+    mini_portile (0.5.2)
+    minitest (5.5.0)
+    mocha (0.14.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.8.2)
+    nokogiri (1.6.1)
+      mini_portile (~> 0.5.0)
+    rack (1.5.2)
+    rack-protection (1.5.3)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rake (10.1.1)
+    safe_yaml (0.9.7)
+    simplecov (0.8.2)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    sinatra (1.4.5)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    tilt (1.4.1)
+    time-warp (1.0.13)
+    twss-classifier (0.0.1)
+    webmock (1.16.1)
+      addressable (>= 2.2.7)
+      crack (>= 0.3.2)
+    xmpp4r (0.5.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  calc
+  meme_generator
+  minitest
+  mocha
+  nokogiri
+  rack-test
+  rake
+  sclemmer-robut!
+  simplecov
+  time-warp
+  twss-classifier
+  webmock

data/README.rdoc

@@ -0,0 +1,199 @@
+= Robut
+
+The friendly plugin-enabled HipChat bot.
+
+== Installation and usage
+
+Robut can be installed by running <tt>gem install robut</tt>. This
+installs the +robut+ binary. When run, +robut+ reads a Chatfile,
+connects to the specified HipChat server and chatroom, and feeds every
+line said in the chatroom through the plugins configured by the
+Chatfile.
+
+Once robut is running, the plugins listen to what's being said in the
+chatroom. Most plugins listen for @replies to robut:
+
+  @robut lunch? # => "Banh Mi!"
+  @robut calc 1 + 1 # => 2
+
+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::Calc] requires the <tt>calc</tt> gem.
+[Robut::Plugin::Weather] requires the <tt>nokogiri</tt> gem.
+[Robut::Plugin::GoogleImages] requires the <tt>google-search</tt> gem.
+
+A list of known 3rd-party plugins is available on the wiki: https://github.com/justinweiss/robut/wiki/Robut-Plugins
+Feel free to add your own creations!
+
+== The Chatfile
+
+When the +robut+ command runs, it looks for and evals ruby code in a
+file called +Chatfile+ in the current directory. You can override the
+configuration file by passing +robut+ a path to a Chatfile as the
+first parameter:
+
+  robut /path/to/Chatfile
+
+The Chatfile is just ruby code. A simple example can be found here: Chatfile[https://github.com/justinweiss/robut/blob/master/examples/Chatfile]
+
+== Robut::Web
+
+You can run Robut as a rack application, which allows it to accept
+incoming post requests (e.g. Heroku deploy hooks, GitHub post-recieve hooks, etc.)
+that can send messages to all connected rooms. Have a look at
+config.ru[https://github.com/justinweiss/robut/blob/master/examples/config.ru] for an example.
+
+=== Adding and configuring plugins
+
+Plugins are ruby classes, so enabling a plugin just requires requiring
+the plugin file, optionally configuring the plugin class, and adding
+the class to the global plugin list:
+
+  require 'robut/plugin/lunch'
+  Robut::Plugin::Lunch.places = ["Banh Mi", "Mad Oven", "Mod Pizza", "Taphouse"]
+  Robut::Plugin.plugins << Robut::Plugin::Lunch
+
+Each plugin can be configured differently, or not at all. It's best to
+look at the docs for the plugins you want to use to figure out what
+kind of configuration they support.
+
+Some plugins might require storage (like the `lunch` plugin).  You can
+configure the type of storage you want to use based on the need for
+persistence.  The default is the HashStore which is in-memory only.  Below
+is an example of using the YamlStore.
+
+  Robut::Connection.configure do |config|
+    # ...
+    Robut::Storage::YamlStore.file = "~/.robut_store"
+    config.store = Robut::Storage::YamlStore
+  end
+
+
+=== Configuring the HipChat connection
+
+The Chatfile also configures the HipChat connection. This is done in a
+Robut::Connection.configure block:
+
+  # Configure the robut jabber connection and you're good to go!
+  Robut::Connection.configure do |config|
+    config.jid = '...@chat.hipchat.com/bot'
+    config.password = 'password'
+    config.nick = 'Bot Nick'
+    config.rooms = ['1234_room_1@conf.hipchat.com', '1234_room_2@conf.hipchat.com']
+
+    # Custom @mention name
+    config.mention_name = 'Bot'
+
+    # Example of the YamlStore which uses a yaml file for persistence
+    Robut::Storage::YamlStore.file = "~/.robut_store"
+    config.store = Robut::Storage::YamlStore
+
+    # Add a logger if you want to debug the connection
+    # config.logger = Logger.new(STDOUT)
+  end
+
+This block usually goes at the end of the Chatfile.
+
+== Built-in plugins
+
+Robut includes a few plugins that we've found useful:
+
+[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] generates meme images using memecaptain.
+
+  @robut meme all_the_things drink; all the beer
+
+[Robut::Plugin::GoogleImages] does a google image search for a query and returns the first result.
+
+  @robut image ship it
+
+[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::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::Quips] stores and posts Bugzilla-style quips.
+
+  @robut add quip It was great when I wrote it!
+  @robut quip # => It was great when I wrote it!
+  @robut remove quip It was great when I wrote it!
+
+[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, include
+the Robut::Plugin module and implement the <tt>handle(time,
+sender_nick, message)</tt> to perform any plugin-specific logic.
+
+Robut::Plugin provides a few helper methods that are documented
+in its class definition.
+
+== Contributing
+
+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. Commit your changes
+4. Push to your branch: `git push origin my_branch`
+5. Send me a pull request
+6. That's it!
+
+== Todo
+
+* More plugins!

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rake/testtask'
+require 'rdoc/task'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+task :build => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+Rake::TestTask.new(:coverage) do |t|
+  t.libs << "test"
+  t.ruby_opts = ["-rsimplecov_helper"]
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  rd.rdoc_dir = 'doc'
+end
+

data/bin/robut

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'robut'
+require 'ostruct'
+require 'logger'
+
+load ARGV[0] || './Chatfile'
+
+Robut::Connection.new.connect
+loop { sleep 1 }

data/examples/Chatfile

@@ -0,0 +1,31 @@
+# Require your plugins here
+require 'robut/plugin/twss'
+require 'robut/storage/yaml_store'
+
+# Add the plugin classes to the Robut plugin list.
+# Plugins are handled in the order that they appear in this array.
+Robut::Plugin.plugins << Robut::Plugin::TWSS
+
+# Configure the robut jabber connection and you're good to go!
+Robut::Connection.configure do |config|
+  # Note that the jid must end with /bot if you don't want robut to
+  # spam the channel, as described by the last bullet point on this
+  # page: https://www.hipchat.com/help/category/xmpp
+  config.jid = '...@chat.hipchat.com/bot'
+  config.password = 'password'
+  config.nick = 'Bot Nick'
+  config.room = '...@conf.hipchat.com'
+
+  # Custom @mention name
+  # config.mention_name = 'Bot'
+
+  # Ignore personal messages
+  # config.enable_private_messaging = false
+
+  # Some plugins require storage
+  Robut::Storage::YamlStore.file = ".robut"
+  config.store = Robut::Storage::YamlStore
+
+  # Add a logger if you want to debug the connection
+  # config.logger = Logger.new(STDOUT)
+end

data/examples/config.ru

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require :default
+
+require 'robut'
+require 'ostruct'
+require 'logger'
+
+load './Chatfile'
+
+Robut::Web.set :connection, Robut::Connection.new.connect
+
+run Robut::Web

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

@@ -0,0 +1,124 @@
+require 'xmpp4r'
+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:
+  #
+  # [+jid+, +password+, +nick+] The HipChat credentials given on
+  #                             https://www.hipchat.com/account/xmpp
+  #
+  # [+rooms+] The chat room(s) to join, with each in the format <tt>jabber_name</tt>@<tt>conference_server</tt>
+  #
+  # [+logger+] a logger instance to use for debug output.
+  attr_accessor :config
+
+  # The Jabber::Client that's connected to the HipChat server.
+  attr_accessor :client
+
+  # The storage instance that's available to plugins
+  attr_accessor :store
+
+  # The roster of currently available people
+  attr_accessor :roster
+
+  # The rooms that robut is connected to.
+  attr_accessor :rooms
+
+  class << self
+    # Class-level config. This is set by the +configure+ class method,
+    # and is used if no configuration is passed to the +initialize+
+    # method.
+    attr_accessor :config
+  end
+
+  # Configures the connection at the class level. When the +robut+ bin
+  # file is loaded, it evals the file referenced by the first
+  # command-line parameter. This file can configure the connection
+  # instance later created by +robut+ by setting parameters in the
+  # Robut::Connection.configure block.
+  def self.configure
+    self.config = OpenStruct.new
+    yield config
+  end
+
+  # Sets the instance config to +config+, converting it into an
+  # OpenStruct if necessary.
+  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.store = self.config.store || Robut::Storage::HashStore # default to in-memory store only
+    self.config.rooms ||= Array(self.config.room) # legacy support?
+    self.config.enable_private_messaging = true if self.config.enable_private_messaging.nil?
+
+    if self.config.logger
+      Jabber.logger = self.config.logger
+      Jabber.debug = true
+    end
+  end
+
+  # Connects to the specified room with the given credentials, and
+  # enters an infinite loop. Any messages sent to the room will pass
+  # through all the included plugins.
+  def connect
+    client.connect
+    client.auth(config.password)
+    client.send(Jabber::Presence.new.set_type(:available))
+
+    self.roster = Jabber::Roster::Helper.new(client)
+    roster.wait_for_roster
+
+    self.rooms = self.config.rooms.collect do |room_name|
+      Robut::Room.new(self, room_name).tap {|r| r.join }
+    end
+
+    if self.config.enable_private_messaging
+      Robut::PM.new(self, rooms)
+    end
+
+    trap_signals
+    self
+  end
+
+  # Send a message to all rooms.
+  def reply(*args, &block)
+    self.rooms.each do |room|
+      room.reply(*args, &block)
+    end
+  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
+  # handlers first.
+  def trap_signals
+    old_signal_callbacks = {}
+    signal_callback = Proc.new do |signal|
+      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
+  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

data/lib/robut/plugin/calc.rb

@@ -0,0 +1,26 @@
+require 'calc'
+
+# A simple calculator. This delegates all calculations to the 'calc'
+# gem.
+class Robut::Plugin::Calc
+  include Robut::Plugin
+
+  # Returns a description of how to use this plugin
+  def usage
+    "#{at_nick} calc <calculation> - replies with the result of <calculation>"
+  end
+  
+  # Perform the calculation specified in +message+, and send the
+  # result back.
+  def handle(time, sender_nick, message)
+    if sent_to_me?(message) && words(message).first == 'calc'
+      calculation = words(message, 'calc').join(' ')
+      begin
+        reply("#{calculation} = #{::Calc.evaluate(calculation)}")
+      rescue
+        reply("Can't calculate that.")
+      end
+    end
+  end
+
+end

data/lib/robut/plugin/echo.rb

@@ -0,0 +1,9 @@
+# A plugin that tells robut to repeat whatever he's told.
+class Robut::Plugin::Echo
+  include Robut::Plugin
+
+  desc "echo <message> - replies to the channel with <message>"
+  match /^echo (.*)/, :sent_to_me => true do |phrase|
+    reply(phrase) unless phrase.empty?
+  end
+end