botfly 0.2.1 → 0.3.0

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/botfly.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{botfly}
-  s.version = "0.2.1"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ryan Neufeld"]
-  s.date = %q{2010-03-17}
+  s.date = %q{2010-03-28}
   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 = [
@@ -43,6 +43,7 @@ Gem::Specification.new do |s|
      "lib/botfly/responder/muc_responder.rb",
      "lib/botfly/responder/presence_responder.rb",
      "lib/botfly/responder/responder.rb",
+     "lib/botfly/responder/subscription_request_responder.rb",
      "retrobot.rb",
      "spec/botfly_spec.rb",
      "spec/spec.opts",

data/lib/botfly.rb

@@ -2,8 +2,7 @@ require 'rubygems'
 
 require 'xmpp4r'
 require 'xmpp4r/muc'
-require 'forwardable'
-require 'logger'
+require 'xmpp4r/roster'
 
 require 'botfly/common_block_acceptor'
 require 'botfly/responder'
@@ -11,6 +10,9 @@ require 'botfly/bot'
 require 'botfly/matcher'
 require 'botfly/muc_client'
 
+require 'logger'
+require 'forwardable'
+
 Thread.abort_on_exception = true
 
 module Botfly
@@ -22,7 +24,7 @@ module Botfly
     @logfile = logfile
     Botfly.logger.info("BOTFLY: #login")
     bot = Botfly::Bot.new(jid,pass)
-    bot.connect
+    bot.connect # Must connect first, since MUC requires an active connection to initiate
     bot.instance_exec(&block)
     return bot # At this point doesn't get returned, as the thread is stopped
   end

data/lib/botfly/bot.rb

@@ -2,51 +2,58 @@ require 'rubygems'
 
 module Botfly
   class Bot < CommonBlockAcceptor
-    attr_reader :jid
+    attr_accessor :responders, :client, :roster, :jid
     
-    def initialize(jid,pass)
+    def initialize(jid,pass, opts = {})
       super
       Botfly.logger.info("  BOT: Bot#new")
       @password = pass
       @jid = Jabber::JID.new(jid)
       @client = Jabber::Client.new(@jid)
       @main_thread = Thread.current
+      if opts[:gtalk]
+        @host = "talk.google.com"
+      end
     end
     
     def connect
-      Botfly.logger.info("  BOT: Connecting to #{@jid}...")
-      @client.connect
+      Botfly.logger.info("  BOT: Connecting to #{@host || @jid}...")
+      @client.connect(@host)
       @client.auth(@password)
       Botfly.logger.info("  BOT: Connected")
       register_for_callbacks
       @client.send(Jabber::Presence.new.set_status("Carrier has arrived"))
+      @roster = Jabber::Roster::Helper.new(@client)
       #Thread.stop
     end
-    
+
     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
-    
+
+    def to_debug_s; "BOT"; end
+
   private
 
     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
-      @client.add_message_callback do |message| 
+      @client.add_subscription_request_callback do |item, pres| # requires Roster helper
+        Botfly.logger.debug("    CB: Got Message")
+        respond_to(:subscription_request, :roster_item => item, :presence => pres)
+      end
+
+      @client.add_message_callback do |message|
         Botfly.logger.debug("    CB: Got Message") 
         respond_to(:message, :message => message)
       end
-      @client.add_presence_callback do |new_presence,old_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

data/lib/botfly/common_block_acceptor.rb

@@ -24,7 +24,7 @@ module Botfly
     end
 
     def remove_responder(id_to_remove)
-      Botfly.logger.info("BOT: Removing responder #{id_to_remove}")
+      Botfly.logger.info("#{self.to_debug_s}: Removing responder #{id_to_remove}")
       @responders.each { |pair| key,chain = pair; chain.reject! {|r| r.id == id_to_remove } }
     end
     

data/lib/botfly/matcher/matcher.rb

@@ -7,5 +7,6 @@ module Botfly
     def match(params)
       raise "AbstractMethodError: You must implement match in a concrete subclass"
     end
+    
   end
 end

data/lib/botfly/muc_client.rb

@@ -4,7 +4,7 @@ module Botfly
   class MUCClient < CommonBlockAcceptor
     attr_reader :bot, :muc
     
-    def room; self; end
+    def room; @block_state; end
     
     def initialize(room, bot, &block)
       super
@@ -13,7 +13,7 @@ module Botfly
       @client = @bot.client
       @room = room
       @domain = "conference.#{@bot.jid.domain}"  # A sensible default for now
-      @resource = @bot.jid.resource
+      @resource = @bot.jid.node
       
       execute(&block) if block_given? # i.e. join(room) do ... end
       return self
@@ -30,8 +30,7 @@ module Botfly
     
 
     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 
+      if (params[:nick] != @resource && Time.now > @connected_at_time + 3)#seconds # Don't run callbacks on the slew of launch messages (at least until I figure out a better way to differentiate them)
         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
@@ -46,6 +45,7 @@ module Botfly
       @muc = Jabber::MUC::SimpleMUCClient.new(@bot.client)
       register_for_callbacks
       @jid = Jabber::JID.new("#{@room}@#{@domain}/#{@resource}")
+      @connected_at_time = Time.now
       @muc.join(@jid)
       Botfly.logger.info("MUC: Done connecting")
     end
@@ -64,7 +64,7 @@ module Botfly
       #@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)}
+      @muc.on_subject {|time,nick,subject| respond_to(:subject, :time => time, :nick => nick, :subject => subject)}
     end
   end
 end

data/lib/botfly/responder/muc_responder.rb

@@ -18,7 +18,8 @@ module Botfly
        @id = @@id += 1
      end
      
-     def method_missing(method,condition,&block)
+     def method_missing(method,*args,&block)
+       condition = args.first
        Botfly.logger.info("RSP: Responder##{method}(#{condition.inspect})")
 
        add_matcher(method,condition)
@@ -51,6 +52,9 @@ module Botfly
        @muc.muc.say(msg)
      end
      
+     def remove(responder_id)
+       @muc.remove_responder(responder_id)
+     end
    private
      def add_matcher(method, condition)
        klass = Botfly.const_get("MUC" + method.to_s.capitalize + "Matcher")

data/lib/botfly/responder/subscription_request_responder.rb

@@ -0,0 +1,17 @@
+module Botfly
+  class SubscriptionRequestResponder < Responder    
+    extend Forwardable
+    def setup_instance_variables(params)
+      Botfly.logger.debug("    RSP: SubscriptionRequestResponder setting up instance variables")
+      @roster_item = params[:roster_item]
+      @presence = params[:presence]
+      @from = @presence.from
+    end
+    
+    def accept
+      @bot.roster.accept_subscription(@from)
+    end
+    def decline
+      @bot.roster.decline_subscription(@from)
+  end
+end

data/retrobot.rb

@@ -4,40 +4,51 @@ require 'fileutils'
 require 'yaml'
 
 config = YAML::load(ARGF.read) if ARGF
-
+#Jabber::debug  = true
 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] = []
+    on.message.from(/^rkneufeld/).body(/^@retro start voting/) 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 }
+        @body.scan(/(\d+)+/).map do |m| 
+          room[:votes][@from] ||= []
+          room[:votes][@from] << m.first.to_i
+        end
       end
     end
-    on.message.from(/^rkneufeld/).body(/^rb stop count/) do
-      say "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="
-      say "Allright, voting is finished"
+    on.message.from(/^rkneufeld/).body(/^@retro stop voting/) do
+      say  "================="
+      say "Allright, voting is finished. Here are the results:"
+      
+      puts "Raw data: #{room[:votes].inspect}"
       remove room[:votes_responder]
+      room[:votes] = room[:votes].map{ |pair| pair[1].first(3) }.flatten
       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]
+      
+      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
+    #   say "Tally HO! Please start your message with +, -, or ∂ (that's option-d) to have it tallied up"
+    #   say "================="
+    #   room[:tally_responders] = []; room[:tally] = {}
+    #   room[:plus] = {}; room[:minus] = {}; room[:delta] = {}
+    # 
+    #   room[:tally_responders] << on.message.body(/^\+(.*)/) { room[:tally][@from]  ||= []; room[:tally][@from] << @body }
+    #   room[:tally_responders] << on.message.body(/^d (.*)/)  { room[:tally][@from]  ||= []; room[:tally][@from] << @body }
+    #   room[:tally_responders] << on.message.body(/^-(.*)/)  { room[:tally][@from]  ||= []; room[:tally][@from] << @body }
+    # end
+    # on.message.from(/^rkneufeld/).body(/^rb stop tally/) do
+    #   room[:tally_responders].each { |id| remove id }
+    #   room[:tally]
+    #   # stored to room[:voted]
+    # end
   end
 end
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Ryan Neufeld
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-17 00:00:00 -05:00
+date: 2010-03-28 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -80,6 +80,7 @@ files:
 - lib/botfly/responder/muc_responder.rb
 - lib/botfly/responder/presence_responder.rb
 - lib/botfly/responder/responder.rb
+- lib/botfly/responder/subscription_request_responder.rb
 - retrobot.rb
 - spec/botfly_spec.rb
 - spec/spec.opts