botfly 0.1.1 → 0.2.1

data/README.rdoc

@@ -1,9 +1,19 @@
-= botfly
+= Botfly
 
-Description goes here.
+Botfly is a Jabber Bot DSL that makes writing bots a joy.
+
+== Installation
+
+   gem install botfly
+
+Go nuts!
+
+== Usage
+
+Coming soon, for now take a look at `example.rb`
 
 == Note on Patches/Pull Requests
- 
+
 * Fork the project.
 * Make your feature addition or bug fix.
 * Add tests for it. This is important so I don't break it in a

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.1

data/botfly.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{botfly}
-  s.version = "0.1.1"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ryan Neufeld"]
-  s.date = %q{2010-03-13}
+  s.date = %q{2010-03-17}
   s.description = %q{Botfly is a Jabber Bot DSL that lets you write bots with ease. Enjoy, while it's still fresh and VERY ALPHA.}
   s.email = %q{ryan@ryanneufeld.ca}
   s.extra_rdoc_files = [
@@ -17,8 +17,7 @@ Gem::Specification.new do |s|
      "README.rdoc"
   ]
   s.files = [
-    ".document",
-     ".gitignore",
+    ".gitignore",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
@@ -27,15 +26,24 @@ Gem::Specification.new do |s|
      "example.rb",
      "lib/botfly.rb",
      "lib/botfly/bot.rb",
+     "lib/botfly/common_block_acceptor.rb",
      "lib/botfly/matcher.rb",
      "lib/botfly/matcher/body_matcher.rb",
      "lib/botfly/matcher/matcher.rb",
+     "lib/botfly/matcher/muc_nick_matcher.rb",
+     "lib/botfly/matcher/muc_text_matcher.rb",
+     "lib/botfly/matcher/muc_time_matcher.rb",
      "lib/botfly/matcher/nick_matcher.rb",
      "lib/botfly/matcher/subject_matcher.rb",
+     "lib/botfly/muc_client.rb",
      "lib/botfly/responder.rb",
+     "lib/botfly/responder/common_responder_methods.rb",
      "lib/botfly/responder/message_responder.rb",
+     "lib/botfly/responder/muc_message_responder.rb",
+     "lib/botfly/responder/muc_responder.rb",
      "lib/botfly/responder/presence_responder.rb",
      "lib/botfly/responder/responder.rb",
+     "retrobot.rb",
      "spec/botfly_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb"

data/example.rb

@@ -1,24 +1,39 @@
 require 'rubygems'
 require 'botfly'
-
+require 'fileutils'
 require 'yaml'
 
 config = YAML::load(ARGF.read) if ARGF
-puts config.inspect
-
-Jabber::debug = false
 
 bot = Botfly.login(config["jid"],config["pass"]) do
-  on(:message).body(/^exit$/) { reply "Goodbye!"; quit }
-  on(:message).nick(/rkneufeld/) do
-    Botfly.logger.info("Callback called")
-    @count ||= 0
-    @count += 1
-    reply("That's the #{@count}th message I've received.")
-  end
+  blame_responder = on.message.body(/^blame/) do |a|
+    match = @body.match(/^blame (.*):(.*)$/)
+    file = match[1]
+    line = match[2].to_i
+
+    project = "/Users/burke/src/jsgithistory"
+    
+    result=nil
+    FileUtils.cd(project) do
+      result = `git blame -p -L#{line},#{line} #{file}`
+    end
 
-  on(:presence) { puts self }
-  connect
+    author = result.scan(/author (.*)\n/).first
+    time   = Time.at(result.scan(/author-time (.*)\n/).first.to_i)
+    commit = result.lines.first.split(' ').first.strip
+    
+    reply "#{author}, #{time}, #{commit}"
+  end
+  join('bots') do
+    on.message do
+      reply "Hi"
+    end
+  end
+  on.message.from(/^rkneufeld/).body(/^kb$/) do
+    reply "Sure thing! You ARE the boss!"
+    remove blame_responder
+    reply "There, all done"
+  end
 end
-Thread.stop
-loop{}
+
+Thread.stop;loop

data/lib/botfly.rb

@@ -2,12 +2,16 @@ require 'rubygems'
 
 require 'xmpp4r'
 require 'xmpp4r/muc'
+require 'forwardable'
+require 'logger'
 
+require 'botfly/common_block_acceptor'
 require 'botfly/responder'
 require 'botfly/bot'
 require 'botfly/matcher'
+require 'botfly/muc_client'
 
-require 'logger'
+Thread.abort_on_exception = true
 
 module Botfly
   def Botfly.logger
@@ -18,7 +22,8 @@ module Botfly
     @logfile = logfile
     Botfly.logger.info("BOTFLY: #login")
     bot = Botfly::Bot.new(jid,pass)
-    bot.instance_eval(&block)
+    bot.connect
+    bot.instance_exec(&block)
     return bot # At this point doesn't get returned, as the thread is stopped
   end
-end
+end

data/lib/botfly/bot.rb

@@ -1,14 +1,15 @@
 require 'rubygems'
 
 module Botfly
-  class Bot
-    attr_reader :responders, :client
+  class Bot < CommonBlockAcceptor
+    attr_reader :jid
+    
     def initialize(jid,pass)
+      super
       Botfly.logger.info("  BOT: Bot#new")
       @password = pass
       @jid = Jabber::JID.new(jid)
       @client = Jabber::Client.new(@jid)
-      @responders = {}
       @main_thread = Thread.current
     end
     
@@ -17,27 +18,27 @@ module Botfly
       @client.connect
       @client.auth(@password)
       Botfly.logger.info("  BOT: Connected")
-      register_for_xmpp_callbacks
+      register_for_callbacks
       @client.send(Jabber::Presence.new.set_status("Carrier has arrived"))
       #Thread.stop
     end
     
-    def on(type, &block)
-      Botfly.logger.info("  BOT: Bot#on")
-      klass = Botfly.const_get(type.to_s.capitalize + "Responder")
-      (@responders[type] ||= []) << responder = klass.new(@client, self, &block)
-      Botfly.logger.info("  BOT: #{type.to_s.capitalize}Responder added to responder chain")
-      return responder
+    def join(room_name,&block)
+      return Botfly::MUCClient.new(room_name,self,&block)
     end
       
     def quit
       @client.close
       @main_thread.continue
     end
-      
+    
+    def to_debug_s
+      "BOT"
+    end
+    
   private
 
-    def register_for_xmpp_callbacks
+    def register_for_callbacks
       Botfly.logger.info("  BOT: Registering for callbacks with client")
 #     @client.add_update_callback {|presence| respond_to(:update, :presence => presence) }
 #     @client.add_subscription_request_callback {|item, pres| } # requires Roster helper
@@ -45,7 +46,7 @@ module Botfly
         Botfly.logger.debug("    CB: Got Message") 
         respond_to(:message, :message => message)
       end
-      @client.add_presence_callback do |old_presence,new_presence| 
+      @client.add_presence_callback do |new_presence,old_presence| 
         Botfly.logger.debug("    CB: Got Presence")
         respond_to(:presence, :old => old_presence, :new => new_presence)
       end
@@ -54,20 +55,7 @@ module Botfly
     
     def respond_to(callback_type, params)
       Botfly.logger.info("  BOT: Responding to callback of type: #{callback_type}")
-      responders = params[:muc] ? @muc_responders[params[:muc]] : @responders
-      responders[callback_type].each {|r| r.callback_with params} if responders[callback_type]
+      @responders[callback_type].each {|r| r.callback_with params} if @responders[callback_type]
     end
-    
-#    def register_for_muc_callbacks(client)
-#      params = {:muc => client}
-##      client.on_join {|time,nick| respond_to(:join, params.merge!(:time=>time,:nick=>nick))}
-#      client.on_leave {|time,nick| respond_to(:leave, params.merge!(:time=>time,:nick=>nick))}
-#      client.on_message {|time,nick,text| respond_to(:message, params.merge!(:time=>time,:nick=>nick,:text=>text))}
-#      client.on_private_message {|time,nick,text| respond_to(:private_message,    params.merge!(:time=>time,:nick=>nick,:text=>text))}
-#      client.on_room_message {|time,text| respond_to(:room_message, params.merge!(:time => time, :text => text))}
-#      client.on_self_leave {|time| respond_to(:self_leave, params.merge!(:time => time)) }
-#      client.on_subject {|time,nick,subject| respond_to(:subject, params.merge!(:time => time, :nick => nickname, :subject => subject))}
-#    end    
-        
   end
-end
+end

data/lib/botfly/common_block_acceptor.rb

@@ -0,0 +1,51 @@
+module Botfly
+  class CommonBlockAcceptor
+    extend Forwardable
+
+    attr_accessor :responders  
+    attr_reader :client
+    
+    def initialize(ignored,ignore)
+      @block_state = {}
+      @responders = {}
+    end
+    
+    ABSTRACT_RAISE_ERROR = "AbstractMethodError: Implement in subclass"
+    def to_debug_s;               raise ABSTRACT_RAISE_ERROR; end
+    def respond_to(type,params);  raise ABSTRACT_RAISE_ERROR; end
+    def on;                       raise ABSTRACT_RAISE_ERROR; end
+
+    def [](key)
+      @block_state[key]
+    end
+    
+    def []=(key, set_to)
+      @block_state[key] = set_to
+    end
+
+    def remove_responder(id_to_remove)
+      Botfly.logger.info("BOT: Removing responder #{id_to_remove}")
+      @responders.each { |pair| key,chain = pair; chain.reject! {|r| r.id == id_to_remove } }
+    end
+    
+    def on
+      return OnRecognizer.new(self)
+    end
+    
+    class OnRecognizer
+      def initialize(obj); @obj = obj; end
+
+      def method_missing(type,&block)
+        Botfly.logger.info("#{@obj.to_debug_s}: Bot#on")
+        klass = Botfly.const_get(@obj.class_prefix + type.to_s.capitalize + "Responder")
+        (@obj.responders[type] ||= []) << responder = klass.new(@obj, &block)
+        Botfly.logger.info("#{@obj.to_debug_s}: #{@obj.class_prefix}#{type.to_s.capitalize}Responder added to responder chain")
+        return responder
+      end
+    end
+    
+    def class_prefix
+      ''
+    end
+  end
+end

data/lib/botfly/matcher.rb

@@ -2,4 +2,8 @@ require 'botfly/matcher/matcher'
 # TODO: Scope the matchers by responder
 require 'botfly/matcher/nick_matcher'
 require 'botfly/matcher/body_matcher'
-require 'botfly/matcher/subject_matcher'
+require 'botfly/matcher/subject_matcher'
+
+require 'botfly/matcher/muc_nick_matcher'
+require 'botfly/matcher/muc_text_matcher'
+require 'botfly/matcher/muc_time_matcher'

data/lib/botfly/matcher/body_matcher.rb

@@ -5,8 +5,8 @@ module Botfly
   class BodyMatcher < Matcher
     def match(params)
       msg = params[:message]
-      Botfly.logger.debug "      MCH: Matching #{@condition.inspect} against #{msg.body.inspect}"
-      Botfly.logger.debug "        RESULT: #{(msg.body =~ @condition).inspect}"
+      Botfly.logger.debug "MCH: Matching #{@condition.inspect} against #{msg.body.inspect}"
+      Botfly.logger.debug "RESULT: #{(msg.body =~ @condition).inspect}"
       return msg.body =~ @condition
     end
   end

data/lib/botfly/matcher/matcher.rb

@@ -1,7 +1,7 @@
 module Botfly
   class Matcher
     def initialize(condition)
-      Botfly.logger.info("      MCH: Creating Matcher")
+      Botfly.logger.info("MCH: Creating Matcher")
       @condition = condition
     end
     def match(params)

data/lib/botfly/matcher/muc_nick_matcher.rb

@@ -0,0 +1,13 @@
+require 'botfly/matcher'
+
+module Botfly
+  class MUCNickMatcher < Matcher
+    def match(params)
+      nick = params[:nick]
+      Botfly.logger.debug "MCH: Matching #{@condition.inspect} against #{nick}"
+      Botfly.logger.debug "RESULT: #{(nick =~ @condition).inspect}"
+      return nick =~ @condition
+    end
+  end
+  MUCFromMatcher = MUCNickMatcher
+end

data/lib/botfly/matcher/muc_text_matcher.rb

@@ -0,0 +1,13 @@
+require 'botfly/matcher'
+
+module Botfly
+  class MUCTextMatcher < Matcher
+    def match(params)
+      text = params[:text]
+      Botfly.logger.debug "MCH: Matching #{@condition.inspect} against #{text}"
+      Botfly.logger.debug "RESULT: #{(text =~ @condition).inspect}"
+      return text =~ @condition
+    end
+  end
+  MUCBodyMatcher = MUCTextMatcher
+end

data/lib/botfly/matcher/muc_time_matcher.rb

@@ -0,0 +1,14 @@
+require 'botfly/matcher'
+
+# FIXME: Make time matching much more robust
+module Botfly
+  class MUCTimeMatcher < Matcher
+    def match(params)
+      time = params[:time]
+      Botfly.logger.debug "MCH: Matching #{@condition.inspect} against #{time}"
+      Botfly.logger.debug "RESULT: #{(time =~ @condition).inspect}"
+      return time =~ @condition
+    end
+  end
+  
+end

data/lib/botfly/matcher/nick_matcher.rb

@@ -5,9 +5,10 @@ module Botfly
   class NickMatcher < Matcher
     def match(params)
       msg = params[:message]
-      Botfly.logger.debug "      MCH: Matching #{@condition.inspect} against #{msg.from.inspect}"
-      Botfly.logger.debug "        RESULT: #{(msg.from.node =~ @condition).inspect}"
+      Botfly.logger.debug "MCH: Matching #{@condition.inspect} against #{msg.from.inspect}"
+      Botfly.logger.debug "RESULT: #{(msg.from.node =~ @condition).inspect}"
       return msg.from.node =~ @condition
     end
   end
+  FromMatcher = NickMatcher
 end

data/lib/botfly/matcher/subject_matcher.rb

@@ -5,8 +5,8 @@ module Botfly
   class SubjectMatcher < Matcher
     def match(params)
       msg = params[:message]
-      Botfly.logger.debug "      MCH: Matching #{@condition.inspect} against #{msg.subject.inspect}"
-      Botfly.logger.debug "        RESULT: #{(msg.subject =~ @condition).inspect}"
+      Botfly.logger.debug "MCH: Matching #{@condition.inspect} against #{msg.subject.inspect}"
+      Botfly.logger.debug "RESULT: #{(msg.subject =~ @condition).inspect}"
       return msg.subject.node =~ @condition
     end
   end

data/lib/botfly/muc_client.rb

@@ -0,0 +1,70 @@
+require 'xmpp4r/muc'
+
+module Botfly
+  class MUCClient < CommonBlockAcceptor
+    attr_reader :bot, :muc
+    
+    def room; self; end
+    
+    def initialize(room, bot, &block)
+      super
+      Botfly.logger.info("MUC: New client created")
+      @bot = bot
+      @client = @bot.client
+      @room = room
+      @domain = "conference.#{@bot.jid.domain}"  # A sensible default for now
+      @resource = @bot.jid.resource
+      
+      execute(&block) if block_given? # i.e. join(room) do ... end
+      return self
+    end
+    
+    def as(resource, &block)
+      Botfly.logger.info("MUC: as #{resource}")
+      @resource = resource
+      execute(&block) if block_given?
+      return self
+    end
+  
+    def leave_room; raise "Implement Me!"; end
+    
+
+    def respond_to(callback_type, params)
+      Botfly.logger.info("MUC: Got callback with time #{params[:time].inspect}")
+      if !params[:time].nil? # Only respond to messages from the server, if time is nil server didn't send 
+        Botfly.logger.info("MUC: Responding to callback of type: #{callback_type} with time of #{params[:time]}")
+        @responders[callback_type].each {|r| r.callback_with params} if @responders[callback_type]
+      end
+    end
+    
+    def to_debug_s; "MUC"; end
+    def class_prefix; "MUC"; end
+  private      
+
+    def connect
+      Botfly.logger.info("MUC: Connecting...")      
+      @muc = Jabber::MUC::SimpleMUCClient.new(@bot.client)
+      register_for_callbacks
+      @jid = Jabber::JID.new("#{@room}@#{@domain}/#{@resource}")
+      @muc.join(@jid)
+      Botfly.logger.info("MUC: Done connecting")
+    end
+
+    def execute(&block)
+      Botfly.logger.info("MUC: Block deteceted, executing...")      
+      connect
+      instance_eval(&block)
+    end
+
+    def register_for_callbacks
+      Botfly.logger.info("MUC: Registering for MUC callbacks")
+      @muc.on_join {|time,nick| respond_to(:join, :time=>time,:nick=>nick)}
+      @muc.on_leave {|time,nick| respond_to(:leave, :time=>time,:nick=>nick)}
+      @muc.on_message {|time,nick,text| respond_to(:message, :time=>time,:nick=>nick,:text=>text)}
+      #@muc.on_private_message {|time,nick,text| respond_to(:private_message,    :time=>time,:nick=>nick,:text=>text)} # Low on the priority to impl. list
+      @muc.on_room_message {|time,text| respond_to(:room_message, :time => time, :text => text)}
+      @muc.on_self_leave {|time| respond_to(:self_leave, :time => time) }
+      @muc.on_subject {|time,nick,subject| respond_to(:subject, :time => time, :nick => nickname, :subject => subject)}
+    end
+  end
+end

data/lib/botfly/responder.rb

@@ -1,3 +1,6 @@
+require 'botfly/responder/common_responder_methods'
 require 'botfly/responder/responder'
 require 'botfly/responder/message_responder'
-require 'botfly/responder/presence_responder'
+require 'botfly/responder/presence_responder'
+require 'botfly/responder/muc_responder'
+require 'botfly/responder/muc_message_responder'

data/lib/botfly/responder/common_responder_methods.rb

@@ -0,0 +1,20 @@
+module Botfly
+  module CommonResponderMethods
+    def send(nick, message, opts = {})
+      Botfly.logger.debug("RSP: Sending message")
+    
+      # Fix the nickname if no domain/resource was given by adding your domain
+      nick += "@" + @bot.jid.domain if nick !~ /@.*/
+      
+      opts = { :type => :chat }.merge(opts)
+      msg = Jabber::Message.new(nick, message)
+      msg.type    = opts[:type]
+      msg.subject = opts[:subject]
+      @client.send(msg)
+    end
+    
+    def remove(responder_id)
+      @bot.remove_responder(responder_id)
+    end
+  end
+end

data/lib/botfly/responder/message_responder.rb

@@ -1,9 +1,8 @@
-require 'forwardable'
 module Botfly
   class MessageResponder < Responder    
     extend Forwardable
     def setup_instance_variables(params)
-      Botfly.logger.debug("    RSP: MessageResponder setting up instance variables")
+      Botfly.logger.debug("RSP: MessageResponder setting up instance variables")
       @message = params[:message]
       @body = @message.body
       @chat_state = @message.chat_state
@@ -14,7 +13,7 @@ module Botfly
     end
     
     def reply(text)
-      Botfly.logger.debug("    RSP: MessageResponder#reply called")
+      Botfly.logger.debug("RSP: MessageResponder#reply called")
       msg = Jabber::Message.new(@from, text)
       msg.type = :chat
       @client.send(msg)

data/lib/botfly/responder/muc_message_responder.rb

@@ -0,0 +1,4 @@
+module Botfly
+  class MUCMessageResponder < MUCResponder
+  end
+end

data/lib/botfly/responder/muc_responder.rb

@@ -0,0 +1,68 @@
+# FIXME: DRY up this and Respnoder 
+module Botfly
+  class MUCResponder < Responder
+     @@id = 1
+     extend Forwardable
+     
+     def_delegator :@muc, :on
+     def_delegator :@bot, :client
+     def_delegator :@muc, :room
+     
+     def initialize(muc,&block)
+       Botfly.logger.info("RSP: #{self.class.to_s}#new")
+       @matcher_chain = []
+       @muc = muc
+       @bot = @muc.bot
+
+       @callback = block if block_given?
+       @id = @@id += 1
+     end
+     
+     def method_missing(method,condition,&block)
+       Botfly.logger.info("RSP: Responder##{method}(#{condition.inspect})")
+
+       add_matcher(method,condition)
+
+       if block_given?
+         Botfly.logger.info("RSP: Callback recorded: #{block.inspect}")
+         @callback = block
+         return @id
+       end
+
+       return self
+     end
+     
+     def callback_with(params)
+       Botfly.logger.debug("RSP: Launching callback with params: #{params.inspect}")
+
+       setup_instance_variables(params)
+       if @matcher_chain.all? {|matcher| matcher.match(params) }
+         Botfly.logger.debug("RSP: All matchers passed")
+         cb = @callback # Ruby makes it difficult to apply & to an instance variable
+         instance_eval &cb
+       end
+     end
+     
+     def leave #room
+       raise "NotImplementedError: Sorry, coming soon!"
+     end
+     
+     def say(msg)
+       @muc.muc.say(msg)
+     end
+     
+   private
+     def add_matcher(method, condition)
+       klass = Botfly.const_get("MUC" + method.to_s.capitalize + "Matcher")
+       @matcher_chain << klass.new(condition)
+
+       Botfly.logger.debug("RSP: Adding to matcher chain: #{@matcher_chain.inspect}")
+     end
+
+     def setup_instance_variables(params)
+       @text = @body = params[:text]
+       @nick = @from = params[:nick]
+       @time = params[:time]
+     end     
+  end
+end

data/lib/botfly/responder/presence_responder.rb

@@ -2,6 +2,24 @@ module Botfly
   class PresenceResponder < Responder
     def setup_instance_variables(params)
       Botfly.logger.debug("    RSP: #{self.class} setting up instance variables")
+            
+      # TODO: Figure out how xmpp works with presence messages so I know what to expect
+      if params[:new]
+        @presence = params[:new]      
+        @from = @presence.from
+        @show = @presence.show
+        @priority = @presence.priority
+        @status = @presence.status
+        @type = @presence.type
+      end
+      
+      if params[:old]
+        @old_presence = params[:old]
+        @old_status = @old_presence.status
+        @old_priority = @old_presence.priority 
+        @old_type = @old_presence.type
+        @old_show = @old_presence.show
+      end
     end
   end
 end

data/lib/botfly/responder/responder.rb

@@ -1,13 +1,18 @@
 module Botfly
   class Responder
-    attr_reader :callback, :callback_type
+    @@id = 1
+    include Botfly::CommonResponderMethods
+    extend Forwardable
+
+    attr_reader :callback, :callback_type, :id, :bot
+    def_delegator :@bot, :client
     
-    def initialize(client,bot,&block)
+    def initialize(bot,&block)
       Botfly.logger.info("    RSP: #{self.class.to_s}#new")
       @matcher_chain = []
       @bot = bot
-      @client = client
       @callback = block if block_given?
+      @id = @@id += 1
     end
     
     def method_missing(method,condition,&block)
@@ -17,7 +22,8 @@ module Botfly
       
       if block_given?
         Botfly.logger.info("    RSP: Callback recorded: #{block.inspect}")
-        @callback = block 
+        @callback = block
+        return @id
       end
       
       return self
@@ -46,14 +52,9 @@ module Botfly
       
       Botfly.logger.debug("    RSP: Adding to matcher chain: #{@matcher_chain.inspect}")
     end
-    
-    # TODO: Check callback is in acceptable list - MUC subclass can override this list
-    def register_with_bot(callback_type)
-      raise "AbstractMethodError: You must implement this method in a concrete subclass"
-    end      
 
     def setup_instance_variables(params)
       raise "AbstractMethodError: You must implement this method in a concrete subclass"
     end
   end
-end
+end

data/retrobot.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'botfly'
+require 'fileutils'
+require 'yaml'
+
+config = YAML::load(ARGF.read) if ARGF
+
+bot = Botfly.login(config["jid"],config["pass"]) do
+  join('lazer').as('retro-bot') do
+    on.message.from(/^rkneufeld/).body(/^rb count/) do
+      say "All votes are now being tallied. You have three votes, use them wisely"
+      say "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="
+      room[:votes] = []
+      room[:votes_responder] = on.message.body(/(\d+)+/) do
+        @body.scan(/(\d+)+/).map {|m| room[:votes] << m.first.to_i }
+      end
+    end
+    on.message.from(/^rkneufeld/).body(/^rb stop count/) do
+      say "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="
+      say "Allright, voting is finished"
+      remove room[:votes_responder]
+      sorted = room[:votes].inject({}) do |h,n| 
+        h[n] ||= 0
+        h[n] += 1
+        h 
+      end.sort {|a,b| b[-1] <=> a[-1] }
+      sorted.each {|pair| say "#{pair[0]} => #{pair[-1]} : #{room[:voted][pair[0]].person} - #{room[:voted][pair[0]].name}" }
+    end
+    on.message.from(/^rkneufeld/).body(/^rb tally$/) do
+      room[:tally_responders] = []
+      room[:plus] = {}; room[:minus] = {}; room[:delta] = {}
+      room[:tally_responders] << on.message.body(/^+(.*)/) { room[:plus][from]  ||= []; room[:plus][from] << match }
+      room[:tally_responders] << on.message.body(/^∂(.*)/) { room[:delta][from] ||= []; room[:delta][from] << match }
+      room[:tally_responders] << on.message.body(/^-(.*)/) { room[:minus][from] ||= []; room[:minus][from] << match }      
+    end
+    on.message.from(/^rkneufeld/).body(/^rb stop tally/) do
+      # remove responders
+      # tally messages
+      # stored to room[:voted]
+    end
+  end
+end
+
+Thread.stop;loop

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 2
   - 1
-  - 1
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Ryan Neufeld
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-13 00:00:00 -06:00
+date: 2010-03-17 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -54,7 +54,6 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files: 
-- .document
 - .gitignore
 - LICENSE
 - README.rdoc
@@ -64,15 +63,24 @@ files:
 - example.rb
 - lib/botfly.rb
 - lib/botfly/bot.rb
+- lib/botfly/common_block_acceptor.rb
 - lib/botfly/matcher.rb
 - lib/botfly/matcher/body_matcher.rb
 - lib/botfly/matcher/matcher.rb
+- lib/botfly/matcher/muc_nick_matcher.rb
+- lib/botfly/matcher/muc_text_matcher.rb
+- lib/botfly/matcher/muc_time_matcher.rb
 - lib/botfly/matcher/nick_matcher.rb
 - lib/botfly/matcher/subject_matcher.rb
+- lib/botfly/muc_client.rb
 - lib/botfly/responder.rb
+- lib/botfly/responder/common_responder_methods.rb
 - lib/botfly/responder/message_responder.rb
+- lib/botfly/responder/muc_message_responder.rb
+- lib/botfly/responder/muc_responder.rb
 - lib/botfly/responder/presence_responder.rb
 - lib/botfly/responder/responder.rb
+- retrobot.rb
 - spec/botfly_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE