campfire-bot 0.0.1

data/lib/event.rb

@@ -0,0 +1,114 @@
+module CampfireBot
+  module Event
+
+    # This is an abstract base class for all event types, not to be used directly.
+    class EventHandler
+
+      attr_reader :kind, :matcher, :plugin, :method
+
+      def self.handles(event_type)
+        @kind = event_type
+      end
+
+      def initialize(matcher, plugin_name, method_name)
+        @matcher  = matcher
+        @plugin   = plugin_name
+        @method   = method_name
+      end
+
+      def run(msg, force = false)
+        if force || match?(msg)
+          Plugin.registered_plugins[@plugin].send(@method, filter_message(msg))
+        else
+          false
+        end
+      end
+
+      protected
+
+      def filter_message(msg)
+        msg
+      end
+    end
+
+    class Command < EventHandler
+      handles :messages
+
+      def match?(msg)
+        (
+          msg[:message][0..0] == '!' ||
+          msg[:message]       =~ Regexp.new("^#{bot.config['nickname']}(,|:)", Regexp::IGNORECASE)
+        ) &&
+        msg[:message].gsub(/^\!/, '').gsub(Regexp.new("^#{bot.config['nickname']}(,|:)?\\s*", Regexp::IGNORECASE), '').split(' ')[0].to_s.downcase == @matcher.downcase
+        # FIXME - the above should be just done with one regexp to pull out the first non-! non-<bot name> word.
+      end
+
+      protected
+
+      def filter_message(msg)
+        msg[:message] = msg[:message].gsub(Regexp.new("^(!|#{bot.config['nickname']}[,:]\\s+)#{@matcher.downcase}\\s?", Regexp::IGNORECASE), '')
+        msg
+      end
+    end
+
+    class Speaker < EventHandler
+      handles :messages
+
+      def match?(msg)
+        msg[:person] == @matcher
+      end
+    end
+
+    class Message < EventHandler
+      handles :messages
+
+      def match?(msg)
+        msg[:message] =~ @matcher
+      end
+    end
+
+    class Interval < EventHandler
+      handles :times
+
+      def initialize(*args)
+        @last_run = ::Time.now
+        super(*args)
+      end
+
+      def match?
+        @last_run < ::Time.now - @matcher
+      end
+
+      def run(msg, force = false)
+        if match?
+          @last_run = ::Time.now
+          Plugin.registered_plugins[@plugin].send(@method, msg)
+        else
+          false
+        end
+      end
+    end
+
+    class Time < EventHandler
+      handles :times
+
+      def initialize(*args)
+        @run = false
+        super(*args)
+      end
+
+      def match?
+        @matcher <= ::Time.now && !@run
+      end
+
+      def run(force = false)
+        if match?
+          @run = true
+          Plugin.registered_plugins[@plugin].send(@method)
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/message.rb

@@ -0,0 +1,30 @@
+module CampfireBot
+  class Message < ActiveSupport::HashWithIndifferentAccess
+    def initialize(attributes)
+      self.merge!(attributes)
+      self[:message] = self['body'] if !!self['body']
+      self[:person] = self['user']['name'] if !!self['user']
+      self[:room] = attributes[:room]
+    end
+    
+    def reply(str)
+      speak(str)
+    end
+    
+    def speak(str)
+      self[:room].speak(str)
+    end
+    
+    def paste(str)
+      self[:room].paste(str)
+    end
+    
+    def upload(file_path)
+      self[:room].upload(file_path)
+    end
+    
+    def play(str)
+      self[:room].play(str)
+    end
+  end
+end

data/lib/plugin.rb

@@ -0,0 +1,77 @@
+module CampfireBot
+  class Plugin
+    @registered_plugins   = {}
+
+    @registered_commands  = []
+    @registered_messages  = []
+    @registered_speakers  = []
+    @registered_intervals = []
+    @registered_times     = []
+
+    class << self
+      attr_reader :registered_plugins,
+                  :registered_commands,
+                  :registered_messages,
+                  :registered_speakers,
+                  :registered_intervals,
+                  :registered_times
+
+      @@config_defaults = {}
+
+      # Registering plugins
+
+      def inherited(child)
+        Plugin.registered_plugins[child.to_s] = child
+      end
+
+      # Event handlers
+
+      def on_command(command, *methods)
+        methods.each do |method|
+          Plugin.registered_commands << Event::Command.new(command, self.to_s, method)
+        end
+      end
+
+      def on_message(regexp, *methods)
+        methods.each do |method|
+          Plugin.registered_messages << Event::Message.new(regexp, self.to_s, method)
+        end
+      end
+
+      def on_speaker(speaker, *methods)
+        methods.each do |method|
+          Plugin.registered_speakers << Event::Speaker.new(speaker, self.to_s, method)
+        end
+      end
+
+      def at_interval(interval, *methods)
+        methods.each do |method|
+          Plugin.registered_intervals << Event::Interval.new(interval, self.to_s, method)
+        end
+      end
+
+      def at_time(timestamp, *methods)
+        methods.each do |method|
+          Plugin.registered_times << Event::Time.new(timestamp, self.to_s, method)
+        end
+      end
+
+      # Declare a plugin configuration parameter with its default value
+      def config_var(name, default)
+        attr_reader name
+        @@config_defaults ||= {}
+        @@config_defaults[self.name] ||= {}
+        @@config_defaults[self.name][name] = default
+      end
+    end
+    def initialize
+      # initialize attr_readers setup with config_var
+      config_prefix = self.class.to_s.underscore
+      (@@config_defaults[self.class.name] || {}).each_pair { |name, default|
+        instance_variable_set("@#{name.to_s}",
+                              bot.config["#{config_prefix}_#{name.to_s}"] ||
+                                default)
+      }
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module CampfireBot
+  VERSION = '0.0.1'
+end

data/plugins/accountability.rb

@@ -0,0 +1,45 @@
+class Accountability < CampfireBot::Plugin
+  on_message /^\[INDAY/i, :save_speaker
+  at_interval 5.minutes, :keep_them_honest
+  
+  def initialize
+    @accountable_people = []
+  end
+  
+  def save_speaker(msg)
+    if msg[:room].name == accountability_room.name
+      puts "WE'RE IN!"
+      @accountable_people << strip_tags(msg[:person]) unless @accountable_people.include?(strip_tags(msg[:person]))
+    end
+  end
+  
+  def keep_them_honest(msg)
+    if accountability_time?
+      unaccountable_people.each do |person|
+        @room.speak("#{person}: We haven't seen your INDAY today. So what's the plan?")
+      end
+      
+      @accountable_people.clear
+    end
+  end
+  
+  private
+  
+  def unaccountable_people
+    accountability_room.users.map { |u| strip_tags(u) } - @accountable_people - [bot.config['nickname']]
+  end
+  
+  def accountability_room
+    @room ||= bot.rooms[bot.config['accountability_room']] || bot.rooms.first
+  end
+  
+  def accountability_time?
+    # Once a day, sometime between 11:00 and 11:05.
+    now = Time.now
+    (Time.mktime(now.year, now.month, now.day, 11, 0)..Time.mktime(now.year, now.month, now.day, 11, 5)).include?(now)
+  end
+  
+  def strip_tags(str)
+    str.gsub(/<\/?[^>]*>/, '').strip
+  end
+end

data/plugins/austin.rb

@@ -0,0 +1,29 @@
+require 'open-uri'
+require 'hpricot'
+
+class Austin < CampfireBot::Plugin
+  BASE_URL = 'http://www.imdb.com/character/ch0002425/quotes'
+
+  on_command 'austin', :austin
+
+  def austin(msg)
+    doc = Hpricot(open(BASE_URL))
+    chunks = []
+    doc.traverse_element("br") {|b| chunks << b if b.next_node != nil && b.next_node.elem? && b.next_node.to_s == '<br />' }
+    chunks.pop
+    random_chunk = rand(chunks.size - 1)
+    raw_quote = chunks[random_chunk].nodes_at(2..(chunks[random_chunk + 1].node_position - chunks[random_chunk].node_position - 1))
+    quote = raw_quote.to_s
+    quote.gsub!(/(\\n)/, "")
+    quote.gsub!(/(<br \/>)/, "\n")
+    quote.gsub!(/^\s/, "")
+    quote.gsub!(/ {2,}/, " ")
+    quote.gsub!(/<\/?[^>]*>/, "")
+    quote.split("\n")
+
+    quote.each {|l| msg.speak l}
+
+  rescue
+    msg.speak 'Austin Powers: Yeah, baby, yeah'
+  end
+end

data/plugins/basecamp.rb

@@ -0,0 +1,48 @@
+require 'hpricot'
+
+class Basecamp < CampfireBot::Plugin
+  on_command 'writeboard', :writeboard
+  
+  def initialize
+    # TODO find a better temp file name
+    @cookie_jar = BOT_ROOT + '/tmp/basecamp-cookies.txt'
+    @writeboard = bot.config['basecamp_writeboard_url']
+    @domain     = @writeboard.split(/\/+/)[1]
+    @username   = bot.config['basecamp_username']
+    @password   = bot.config['basecamp_password']
+    @ssl        = !!bot.config['basecamp_use_ssl']
+  end
+  
+  def writeboard(msg)
+    msg.paste get_contents
+  end
+  
+  private
+  
+  # TODO escape stuff here. output = `#{Escape.shell_command(['figlet', '--', m[:message]])}`
+  def get_contents
+    # Prime the cookie jar: log in.
+    basecamp_login      = `curl -c #{@cookie_jar} -b #{@cookie_jar} -d "user_name=#{@username}&password=#{@password}" -L http#{'s' if @ssl}://#{@domain}/login/authenticate`
+    
+    # Fetch the contents of the writeboard redirect page
+    writeboard_redir    = `curl -c #{@cookie_jar} -b #{@cookie_jar} -L #{@writeboard}`
+    
+    # Simulate the javascripted login to the writeboard site
+    redir_form          = Hpricot(writeboard_redir).search('form').first
+    writeboard_url      = redir_form['action'].gsub(/\/login$/, '')
+    writeboard_author   = bot.config['nickname']
+    writeboard_password = redir_form.search("input[@name='password']").first['value']
+    
+    writeboard_login    = `curl -c #{@cookie_jar} -b #{@cookie_jar} -d "author_name=#{writeboard_author}&password=#{writeboard_password}" -L #{redir_form['action']}`
+    
+    # Now we can get the contents of the writeboard's page, which contains a link to the text export
+    writeboard_page     = Hpricot(`curl -c #{@cookie_jar} -b #{@cookie_jar} -L #{writeboard_url}`)
+    
+    export_link         = 'http://123.writeboard.com' + writeboard_page.search("a[@href*='?format=txt']").first['href']
+    
+    # Finally, grab the text export
+    writeboard_text     = `curl -c #{@cookie_jar} -b #{@cookie_jar} #{export_link}`
+    
+    return writeboard_text
+  end
+end

data/plugins/beer.rb

@@ -0,0 +1,214 @@
+require 'yaml'
+
+class Beer < CampfireBot::Plugin
+  
+  # Beer::COMMAND_REGEXP = "^(?:!|#{bot.config['nickname']},\\s+)"
+  
+  # Beer::GIVE_REGEXP =  Regexp.new("#{Beer::COMMAND_REGEXP}([a-z\\s\\.]{4,12})([0-9]+)*", Regexp::IGNORECASE)
+  # Beer::CREDIT_REGEXP = //
+  # Beer::BALANCE_REGEXP = //
+    
+  # on_message @debit_matcher, :respond
+  # on_message Regexp.new("#{CREDIT_REGEXP.source}", Regexp::IGNORECASE), :credit_cmd
+  on_command 'give_beer', :give_beer
+  on_command 'demand_beer', :demand_beer
+  on_command 'redeem_beer', :redeem_beer 
+  on_command 'balance', :balance_cmd
+  
+  # balances: {'josh' => {'party1' => 1 }, 'party1': '}
+  
+  class BadArgumentException < Exception
+  end
+  
+  def give_beer(msg)
+    give_or_demand_beer(msg, :give)
+  end
+  
+  def demand_beer(msg)
+    give_or_demand_beer(msg, :demand)
+  end
+  
+  def redeem_beer(msg)
+    give_or_demand_beer(msg, :redeem)
+  end
+  
+  def balance_cmd(msg)
+    @balances = init()
+    begin
+      if msg[:message].empty?
+        return
+        # raise BadArgumentException.new, "Sorry, I don't know whom to #{trans_type_msg}"
+      end
+                
+      speaker = msg[:person]
+      payee = msg[:message]
+      
+      bal = balance(speaker, payee)
+      
+      units = bal.abs == 1 ? "beer" : "beers"
+      
+      if bal < 0
+        msg.speak("#{payee} owes you #{bal * -1} #{units}")
+      elsif bal > 0
+        msg.speak("You owe #{payee} #{bal} #{units}")
+      else
+        msg.speak("You and #{payee} are even")
+      end
+        
+      rescue BadArgumentException => exception
+        msg.speak(exception.message)
+      end
+  end
+  
+  
+  def give_or_demand_beer(msg, trans_type)     
+    args = msg[:message].match(/(^[a-z\s\.\-]+?)(\s*\-*[0-9]*)$/i)
+    # puts "args = #{args.inspect}"
+    # puts "args[0] = #{args[0]}"
+    # puts "args[1] = #{args[1]}"
+    # puts "args[2] = #{args[2]}"
+
+    trans_type_msg = {:give => 'give beer to', :demand => 'demand beer from', :redeem => 'redeem beer from'}[trans_type]
+    
+    begin
+  
+      if args.nil?
+        raise BadArgumentException.new, "Sorry, I don't know whom to #{trans_type_msg}"
+      end
+      
+      payee = args[1].strip
+      speaker = msg[:person]
+            
+      if args[2] != "" and args[2].to_i == 0
+        raise BadArgumentException.new, "Sorry, I don't accept non-integer amounts"
+      end
+      
+      amt = args[2] != "" ? args[2].to_i : 1
+      
+      if amt <= 0
+        raise BadArgumentException.new, "Sorry, I don't accept negative numbers as an argument"
+      end
+      
+      case trans_type
+      when :give
+        # no change - this is a debit
+      when :demand
+        amt = amt * -1 # this is a credit
+      when :redeem
+        # amt = amt * -1 # this is a credit
+        # no change - this is a debit
+        if bal = balance(speaker, payee) == 0
+          raise BadArgumentException.new, "#{payee} didn't owe you any beers to begin with."
+        end
+      end
+      
+      beer_transaction(speaker, payee, amt)
+
+      bal = balance(speaker, payee)
+      
+      # puts "post transaction balance = #{bal}"
+      if bal > 0
+        msg.speak("Okay, you now owe #{payee} #{bal} beers")
+      elsif bal < 0
+        msg.speak("Okay, #{payee} now owes you #{bal * -1} beers")
+      else
+        msg.speak("Okay, you and #{payee} are now even")
+      end
+      
+    rescue BadArgumentException => exception
+      msg.speak(exception.message)
+    end
+    
+  end
+  
+  
+  def beer_transaction(user1, user2, amount)
+    #beer_transaction user1, user2, 1 : user1 owes user2 a beer
+    #beer_transaction user1, user2, -1 : user1 demands a beer from user2 (user1 owes user2 -1 beers)
+    @balances = init()
+    # puts 'beer_transaction'
+    # p "beer_transaction start: #{@balances.inspect}"
+    # p "beer_transaction args: #{user1}, #{user2}, #{amount}"
+    user1 = user1.downcase.strip
+    user2 = user2.downcase.strip
+    
+    if !@balances.key?(user1)
+      @balances[user1] = {}
+    end
+    
+    if !@balances[user1].key?(user2)
+      @balances[user1][user2] = 0
+    end
+    
+    @balances[user1][user2] += amount
+    
+    # p "beer_transaction end: #{@balances.inspect}"
+    write
+    
+  end
+    
+  
+  
+  def balance(user1, user2)
+    # verb => user1 owes user2 #{balance} beers
+    # bal(user1, user2) = 1 # user1 is owed a beer from user2
+    # bal(user1, user2) = -1 # user1 is owed -1 beers from user 2 (meaning user2 owes user1)
+    
+    @balances = init()
+    
+    # puts "hash is #{hash}, @balances[#{hash}] = #{@balances[hash]}"
+    user1 = user1.downcase.strip
+    user2 = user2.downcase.strip
+    
+    if @balances.key?(user1) and @balances[user1].key?(user2)
+      bal1 = @balances[user1][user2]
+    else 
+      bal1 = 0
+    end
+    
+    if @balances.key?(user2) and @balances[user2].key?(user1)
+      bal2 = @balances[user2][user1]
+    else 
+      bal2 = 0
+    end
+    
+    bal = bal1 - bal2
+    
+    if (@balances.key?(user1) ? !@balances[user1].key?(user2) : true) and 
+      (@balances.key?(user2) ? !@balances[user2].key?(user1) : true)
+      raise BadArgumentException.new, "Sorry, you don't have any beer transactions with anyone named #{user2}"
+    end
+    
+    bal
+  end
+    
+  def get_hash(user_1, user_2)
+    user1 = user_1.downcase
+    user2 = user_2.downcase
+    
+    [user1,user2].sort.to_s
+    # if user1 < user2
+    #   "#{user1}#{user2}"
+    # else
+    #   "#{user2}#{user1}"
+    # end
+  end
+  
+  def init
+    # puts "entering init()"
+    YAML::load(File.read(File.join(BOT_ROOT, 'tmp', 'beer.yml')))
+  end
+  
+  def write
+    File.open(File.join(BOT_ROOT, 'tmp', 'beer.yml'), 'w') do |out|
+      YAML.dump(@balances, out)
+    end
+    
+  end
+    
+  def reload(msg)
+    @balances = init()
+    speak("ok, reloaded #{@balances.size} balances")
+  end
+
+end