botfly 0.3.3 → 0.3.4

data/TODO

@@ -1,12 +1,35 @@
 Botfly Todo List (by priority)
 ==============================
+* Have Bot.new and Bot#run instead of just #login that always runs
 * Replace CommonBlockAcceptor responder chain array with ResponderChain object
 ** Spec & create ResponderChain class
 ** Have responder chain stop call first responder ONLY after reaching a match
 ** Additionally provide DSL for on... chain to give priority to responders (that is to say one can specify which responders fire first)
 * Finish speccing matchers, responders
 * More robust instance methods on responders (i.e. provide access to variables through methods and not ivars)
+    -> In fact, the base Responder class should, for each parameter, set up a set of default instance methods for each parameter (since, largely, these parameters are standard across their names)
+       This will DRY up the "setup_instance_variables" as that paradigm performs horribly in flog and other stats
 * Additional matchers on single and multi-user chat (not sure what, but doesn't feel complete)
 * Add configure method to accept list of configuration paramaters.
 * Support any of a bevy of features provided by xmpp4r
 
+
+Unsorted
+========
+* Some sort of xmpp4r mock/helper to more easily test external services
+    I'm imagining skipping most of the xml junk that goes on internally in xmpp4r. Something maybe like this:
+
+    it "should reply 'yo!' to any message" do
+    
+      bot = Botfly.new("doesn't", "matter") do
+        on.message do
+          reply "yo!"
+        end
+        on.subscription_request { accept }
+      end
+      
+      bot.should 
+        receive(:message, :from => 'jim@someserver.com/home', :message => "Hi!").
+        then reply_with "yo!"
+        # A full range of starting custom matchers (get, be_added_by, something, etc.) and set of response matcher
+    end

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.3.4

data/botfly.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{botfly}
-  s.version = "0.3.3"
+  s.version = "0.3.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ryan Neufeld"]
-  s.date = %q{2010-04-05}
+  s.date = %q{2010-04-10}
   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 = [
@@ -28,6 +28,7 @@ Gem::Specification.new do |s|
      "example.rb",
      "lib/botfly.rb",
      "lib/botfly/bot.rb",
+     "lib/botfly/callback_context.rb",
      "lib/botfly/common_block_acceptor.rb",
      "lib/botfly/matcher.rb",
      "lib/botfly/matcher/body_matcher.rb",
@@ -41,13 +42,12 @@ Gem::Specification.new do |s|
      "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",
      "lib/botfly/responder/subscription_request_responder.rb",
      "retrobot.rb",
      "spec/botfly/bot_spec.rb",
+     "spec/botfly/callback_context_spec.rb",
      "spec/botfly/common_block_acceptor_spec.rb",
      "spec/botfly/matcher/body_matcher_spec.rb",
      "spec/botfly/matcher/matcher_spec.rb",
@@ -59,9 +59,7 @@ Gem::Specification.new do |s|
      "spec/botfly/muc_client_spec.rb",
      "spec/botfly/responder/common_responder_methods_spec.rb",
      "spec/botfly/responder/message_responder_spec.rb",
-     "spec/botfly/responder/muc_message_responder_spec.rb",
      "spec/botfly/responder/muc_responder_spec.rb",
-     "spec/botfly/responder/presence_responder_spec.rb",
      "spec/botfly/responder/responder_spec.rb",
      "spec/botfly/responder/subscription_request_responder_spec.rb",
      "spec/botfly_spec.rb",
@@ -77,6 +75,7 @@ Gem::Specification.new do |s|
   s.summary = %q{A quick and easy DSL for generating Jabber bots}
   s.test_files = [
     "spec/botfly/bot_spec.rb",
+     "spec/botfly/callback_context_spec.rb",
      "spec/botfly/common_block_acceptor_spec.rb",
      "spec/botfly/matcher/body_matcher_spec.rb",
      "spec/botfly/matcher/matcher_spec.rb",
@@ -88,9 +87,7 @@ Gem::Specification.new do |s|
      "spec/botfly/muc_client_spec.rb",
      "spec/botfly/responder/common_responder_methods_spec.rb",
      "spec/botfly/responder/message_responder_spec.rb",
-     "spec/botfly/responder/muc_message_responder_spec.rb",
      "spec/botfly/responder/muc_responder_spec.rb",
-     "spec/botfly/responder/presence_responder_spec.rb",
      "spec/botfly/responder/responder_spec.rb",
      "spec/botfly/responder/subscription_request_responder_spec.rb",
      "spec/botfly_spec.rb",

data/lib/botfly.rb

@@ -1,3 +1,8 @@
+# I know this isn't completely proper, but for some reason my lib wasn't on the loadpath, and i SHOULD be able to assume it is
+unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+  $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+end
+
 require 'rubygems'
 
 require 'logger'
@@ -7,6 +12,7 @@ require 'xmpp4r'
 require 'xmpp4r/muc'
 require 'xmpp4r/roster'
 
+require 'botfly/callback_context'
 require 'botfly/common_block_acceptor'
 require 'botfly/responder'
 require 'botfly/bot'

data/lib/botfly/bot.rb

@@ -50,7 +50,7 @@ module Botfly
       end
 
       @client.add_presence_callback do |new_presence,old_presence|
-        respond_to(:preesence, :old => old_presence, :new => new_presence)
+        respond_to(:preesence, :old_presence => old_presence, :presence => new_presence)
       end
 
     end

data/lib/botfly/callback_context.rb

@@ -0,0 +1,45 @@
+module Botfly
+  class CallbackContext
+    def initialize(caller, params)
+      setup_params(params)
+      @caller = caller
+    end
+    def method_missing(name, *args)
+      @caller.send(name,*args) if name.to_s.scan(/^setup/).empty?
+    end
+  private
+    # OK, so. Get the instance's eigenclass, then, call the private method define_method - thus created the method called #{name} that returns value. Basically attr_reader but for any generic variable.
+    def expose(name, value)
+      (class<<self;self;end).send(:define_method,name,proc{value})
+    end
+    def setup_params(params)
+      params.each do |name,value|
+        send(:"setup_#{name}", value)
+      end
+    end
+    def setup_roster_item(roster_item)
+      expose(:roster_item, roster_item)
+    end
+    def setup_message(message)
+      expose(:message, message)
+      expose(:body, message.body)
+      expose(:chat_state, message.chat_state)
+      expose(:subject, message.subject)
+      expose(:type, message.type)
+      expose(:from, message.from)
+      expose(:to, message.to)
+    end
+    def setup_presence(presence, pre = '')
+      expose(:"#{pre}presence", presence)
+      expose(:"#{pre}from", presence.from)
+      expose(:"#{pre}show", presence.show)
+      expose(:"#{pre}priority", presence.priority)
+      expose(:"#{pre}status", presence.status)
+      expose(:"#{pre}type", presence.type)
+    end
+    def setup_old_presence(presence); setup_presence(presence, 'old_') end
+    def setup_time(time); expose(:time, time) end
+    def setup_nick(nick); expose(:from, nick); end
+    def setup_text(text); expose(:text, text); expose(:body, text); end
+  end
+end

data/lib/botfly/common_block_acceptor.rb

@@ -35,7 +35,7 @@ module Botfly
 
       def method_missing(name,&block)
         Botfly.logger.info("#{@obj.to_debug_s}: Bot#on")
-        klass = Botfly.const_get(@obj.class_prefix + name.to_s.capitalize + "Responder")
+        klass = Botfly.const_get(@obj.class_prefix + name.to_s.split('_').map(&:capitalize).join + "Responder")
         (@obj.responders[name] ||= []) << responder = klass.new(@obj, &block)
         Botfly.logger.info("#{@obj.to_debug_s}: #{@obj.class_prefix}#{name.to_s.capitalize}Responder added to responder chain")
         return responder

data/lib/botfly/matcher.rb

@@ -3,7 +3,6 @@ require 'botfly/matcher/matcher'
 require 'botfly/matcher/nick_matcher'
 require 'botfly/matcher/body_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/muc_client.rb

@@ -45,7 +45,7 @@ module Botfly
       @muc = Jabber::MUC::SimpleMUCClient.new(@bot.client)
       register_for_callbacks
       @jid = Jabber::JID.new("#{@room}@#{@domain}/#{@resource}")
-      @muc.join(@jid, nil, :history => false)
+      @muc.join(@jid,nil)#@muc.join(@jid, nil, :history => false)
       Botfly.logger.info("MUC: Done connecting")
     end
 

data/lib/botfly/responder.rb

@@ -1,8 +1,5 @@
-# TODO: Dry this up
 require 'botfly/responder/common_responder_methods'
 require 'botfly/responder/responder'
 require 'botfly/responder/message_responder'
-require 'botfly/responder/presence_responder'
 require 'botfly/responder/muc_responder'
-require 'botfly/responder/muc_message_responder'
 require 'botfly/responder/subscription_request_responder'

data/lib/botfly/responder/common_responder_methods.rb

@@ -1,6 +1,6 @@
 module Botfly
   module CommonResponderMethods
-    def send(nick, message, opts = {})
+    def tell(nick, message, opts = {})
       Botfly.logger.debug("RSP: Sending message")
     
       # Fix the nickname if no domain/resource was given by adding your domain

data/lib/botfly/responder/message_responder.rb

@@ -1,16 +1,6 @@
 module Botfly
   class MessageResponder < Responder    
     extend Forwardable
-    def setup_instance_variables(params)
-      Botfly.logger.debug("RSP: MessageResponder setting up instance variables")
-      @message = params[:message]
-      @body = @message.body
-      @chat_state = @message.chat_state
-      @subject = @message.subject
-      @type = @message.type
-      @from = @message.from
-      @to = @message.to
-    end
     
     def reply(text)
       Botfly.logger.debug("RSP: MessageResponder#reply called")

data/lib/botfly/responder/responder.rb

@@ -6,22 +6,32 @@ module Botfly
 
     attr_reader :callback, :callback_type, :id, :bot
     def_delegator :@bot, :client
+    def_delegator :@bot, :quit
     
     def initialize(bot,&block)
-      Botfly.logger.info("    RSP: #{self.class.to_s}#new")
+      Botfly.logger.info("RSP: #{self.class.to_s}#new")
       @matcher_chain = []
       @bot = bot
       @callback = block if block_given?
       @id = @@id += 1
     end
     
+    ##
+    # Allows for the nifty DSL that lets you chain matchers after specifying a callback type.
+    #
+    # 
+    # e.g. on.message.matcher1(:foo).matcher2(:bar) { ... }
+    #
+    # @param [String] method The name of the matcher to be added to the matcher chain
+    # @param condition The condition or set of conditions to be matched against when attempting execution.
+    # @return [self] Chain to your hearts content.
     def method_missing(method,condition,&block)
-      Botfly.logger.info("    RSP: Responder##{method}(#{condition.inspect})")
+      Botfly.logger.info("RSP: Responder##{method}(#{condition.inspect})")
       
       add_matcher(method,condition)
       
       if block_given?
-        Botfly.logger.info("    RSP: Callback recorded: #{block.inspect}")
+        Botfly.logger.info("RSP: Callback recorded: #{block.inspect}")
         @callback = block
         return @id
       end
@@ -29,32 +39,33 @@ module Botfly
       return self
     end
     
+    ##
+    # Attempt to execute the callback on a responder. Only called if all matchers pass based on the supplied params
+    #
+    # @param [Hash] params The parameters necessary to execute the callback. Supplied by xmpp4r and pass through to here.
     def callback_with(params)
-      Botfly.logger.debug("    RSP: Launching callback with params: #{params.inspect}")
+      Botfly.logger.debug("RSP: Launching callback with params: #{params.inspect}")
 
-      setup_instance_variables(params)
+      context = callback_context(params)
       if @matcher_chain.all? {|matcher| matcher.match(params) }
-        Botfly.logger.debug("      RSP: All matchers passed")
+        Botfly.logger.debug("RSP: All matchers passed")
         cb = @callback # Ruby makes it difficult to apply & to an instance variable
-        instance_eval &cb
+        context.instance_eval &cb
       end
     end
 
-    def quit
-      @bot.quit
-    end
     # TODO: add other @client actions as delegates    
 
   private
     def add_matcher(method, condition)
-      klass = Botfly.const_get(method.to_s.capitalize + "Matcher")
+      klass = Botfly.const_get(method.to_s.split('_').map(&:capitalize).join + "Matcher")
       @matcher_chain << klass.new(condition)
       
-      Botfly.logger.debug("    RSP: Adding to matcher chain: #{@matcher_chain.inspect}")
+      Botfly.logger.debug("RSP: Adding to matcher chain: #{@matcher_chain.inspect}")
     end
 
-    def setup_instance_variables(params)
-      raise "AbstractMethodError: You must implement this method in a concrete subclass"
+    def callback_context(params)
+      Botfly::CallbackContext.new(self, params)
     end
   end
 end

data/lib/botfly/responder/subscription_request_responder.rb

@@ -1,13 +1,6 @@
 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
-    
+    extend Forwardable    
     def accept
       @bot.roster.accept_subscription(@from)
     end

data/spec/botfly/bot_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 include Botfly
 describe Botfly::Bot do
@@ -29,13 +29,15 @@ describe Botfly::Bot do
   end
 
   describe "#register_for_callbacks" do
-    let(:bot) { Bot.new('jid', 'pass') }
-    before(:each) { stub_jabber_client }
+    subject { Bot.new('jid', 'pass') }
+    before(:each) { stub_jabber_client; }
+    after(:each)  { subject.send(:register_for_callbacks)}
     it "should register calls for each callback" do
-      bot.roster.should_receive :add_subscription_request_callback
-      bot.client.should_receive :add_presence_callback
-      bot.client.should_receive :add_message_callback
-      bot.send(:register_for_callbacks)
+      subject.instance_variable_set(:"@roster", mock("roster")) # I would prefer to do this elsewhere
+      subject.roster.should_receive :add_subscription_request_callback
+      subject.client.should_receive :add_presence_callback
+      subject.client.should_receive :add_message_callback
+
     end
   end
 

data/spec/botfly/callback_context_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+include Botfly
+describe CallbackContext do
+  let(:caller) { mock "Caller" }
+  let(:params) { Hash.new }
+  subject { CallbackContext.new(caller,params) }
+
+  it "should pass along unknown methods to the caller" do
+    caller.should_receive(:foo)
+    subject.foo
+  end
+  
+  it "should pass along complex method calls to the caller" do
+    caller.should_receive(:foo).with(:bar,:baz)
+    subject.foo(:bar,:baz)
+  end
+  
+  describe "#setup_params" do
+    it "should call setup for each parameter passed" do
+      subject.should_receive(:setup_message)
+      subject.send(:setup_params, {:message => :foo})
+    end
+  end
+  
+  describe "#expose" do
+    it "should define a method that returns value" do
+      subject.send(:expose, :foo, :bar)
+      subject.foo.should be :bar
+    end
+    it "should not define methods on the class" do
+      expect { CallbackContext.send(:expose, :foo, :bar) }.to raise_error NoMethodError
+    end
+  end
+  
+  context "private setup method" do
+    let(:presence) do
+      stub("Presence", :from => :from, :show => :show, :priority => :priority,
+        :status => :status, :type => :type)
+    end
+    let(:message) do
+      stub("Message", :body => :body, :to => :to, :from => :from, 
+        :chat_state => :chat_state, :type => :type, :subject => subject) 
+    end
+    
+    describe "#setup_roster_item" do
+      subject { CallbackContext.new(caller,params) }
+      it { subject.respond_to?(:setup_roster_item, true).should be true }
+      it "should set up instance methods for supplied values" do
+        subject.send(:setup_roster_item, :foo)
+        subject.roster_item.should be :foo
+      end
+    end
+    
+    describe "#setup_message" do
+      subject { CallbackContext.new(caller,params) }
+      it { subject.respond_to?(:setup_message, true).should be true }
+      it "should set up instance methods for supplied values" do
+        subject.send(:setup_message, message)
+        subject.message.should be message
+        subject.body.should be message.body
+        subject.to.should be message.to
+        subject.from.should be message.from
+        subject.chat_state.should be message.chat_state
+        subject.type.should be message.type
+      end
+    end
+    
+    describe "#setup_presence" do
+      subject { CallbackContext.new(caller,params) }
+      it { subject.respond_to?(:setup_presence, true).should be true }
+      it "should set up instance methods for supplied values" do
+        subject.send(:setup_presence, presence)
+        subject.presence.should be :presence
+        subject.from.should be :from
+        subject.show.should be :show
+        subject.priority.should be :priority
+        subject.status.should be :status
+        subject.type.should be :type
+      end
+    end
+    
+    describe "#setup_old_presence" do
+      subject { CallbackContext.new(caller,params) }
+      it { subject.respond_to?(:setup_old_presence, true).should be true }
+      it "should set up instance methods for supplied values" do
+        subject.send(:setup_old_presence, presence)
+        subject.old_presence.should be :presence
+        subject.old_from.should be :from
+        subject.old_show.should be :show
+        subject.old_priority.should be :priority
+        subject.old_status.should be :status
+        subject.old_type.should be :type
+      end
+    end
+    
+    describe "#setup_time" do
+      subject { CallbackContext.new(caller,params) }
+      it { subject.respond_to?(:setup_time, true).should be true }
+      it "should set up instance methods for supplied values" do
+        subject.send(:setup_time, :foo)
+        subject.time.should be :foo
+      end
+    end
+    
+    describe "#setup_nick" do
+      subject { CallbackContext.new(caller,params) }
+      it { subject.respond_to?(:setup_nick, true).should be true }
+      it "should set up instance methods for supplied values" do
+        subject.send(:setup_nick, :foo)
+        subject.from.should be :foo
+      end
+    end
+    
+    describe "#setup_text" do
+      subject { CallbackContext.new(caller,params) }
+      it { subject.respond_to?(:setup_text, true).should be true }
+      it "should set up instance methods for supplied values" do
+        subject.send(:setup_text, :foo)
+        subject.text.should be :foo
+        subject.body.should be :foo
+      end
+    end
+  end
+end

data/spec/botfly/common_block_acceptor_spec.rb

@@ -47,7 +47,7 @@ describe CommonBlockAcceptor do
   context "::OnRecognizer" do
     let(:acceptor) { CommonBlockAcceptor.new }
     let(:on) { acceptor.on } 
-    before(:each) do
+    before(:all) do
       class FooResponder; def initialize(bar); end; end
       class FooBarResponder; def initialize(baz);end; end
     end
@@ -56,7 +56,12 @@ describe CommonBlockAcceptor do
       FooResponder.should_receive(:new)
       on.foo
     end
-
+    
+    it "should turn snake_case into CamelCase" do
+      FooBarResponder.should_receive(:new)
+      on.foo_bar
+    end
+    
     it "should add class prefix to front of responder class" do
       acceptor.stub(:class_prefix).and_return('Foo')
       Botfly.should_receive(:const_get).with('FooBarResponder').and_return(FooBarResponder)

data/spec/botfly/matcher/body_matcher_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::BodyMatcher do
+  it "should be tested"
+end

data/spec/botfly/matcher/matcher_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::Matcher do
+  it "should be tested"
+end

data/spec/botfly/matcher/muc_nick_matcher_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::MUCNickMatcher do
+  it "should be tested"
+end

data/spec/botfly/matcher/muc_text_matcher_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::MUCTextMatcher do
+  it "should be tested"
+end

data/spec/botfly/matcher/muc_time_matcher_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::MUCTimeMatcher do
+  it "should be tested"
+end

data/spec/botfly/matcher/nick_matcher_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::NickMatcher do
+  it "should be tested"
+end

data/spec/botfly/matcher/subject_matcher_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::SubjectMatcher do
+  it "should be tested"
+end

data/spec/botfly/responder/common_responder_methods_spec.rb

@@ -20,16 +20,18 @@ describe CommonResponderMethods do
     before(:each) do
       responder.bot.stub_chain(:jid,:domain => 'foo.com')
     end
-    after( :each) { responder.send ('bar', "message")}
+    after(:each) { responder.tell('foo@bar.baz/home', "message") }
     subject { responder }
+    
     it "should pass the message along to the bot's jabber client" do
-      responder.client.should_receive :send
+      responder.client.should_receive(:send).with(an_instance_of(Jabber::Message))
     end
-    it "should pass the string given as a the message's body" do
-      pending
-    end
-    it "should pass the nickname given as the message's destination" do
-      pending
+
+    it "should set the nickname and body appropriately in the message" do
+      responder.client.should_receive(:send) do |msg|
+        msg.to.to_s.should == 'foo@bar.baz/home'
+        msg.body.should == 'message'
+      end
     end
   end
 end

data/spec/botfly/responder/message_responder_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::MessageResponder do
+  it "should be tested"
+end

data/spec/botfly/responder/muc_responder_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::MUCResponder do
+  it "should be tested"
+end

data/spec/botfly/responder/responder_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::Responder do
+  describe ".new" do
+    subject { Responder.new(mock("bot")) }
+    it { should assign :matcher_chain }
+    it { should assign :bot }
+    it { should_not assign :callback }
+    it "should assign callback if block given" do
+      proc = Proc.new {}
+      Responder.new(mock("bot"), &proc).should assign :callback
+    end
+    it "should give out incremental IDs" do
+      bot = mock("bot")
+      @id = Responder.new(bot).id
+      expect { @id = Responder.new(bot).id }.to change {@id}.by(1)
+    end
+  end
+
+  context "instance" do
+    let(:bot) { mock "bot" }
+    subject { Responder.new(bot) }
+    it "should delegate client to @bot" do
+      bot.should_receive :client
+      subject.client
+    end
+    it "should delegate quit to @bot" do
+      bot.should_receive :quit
+      subject.quit
+    end
+    it "should provide attr_reader for @bot" do
+      subject.bot.should be bot
+    end
+    it { should be_a CommonResponderMethods }
+  end
+
+  describe "#method_missing" do
+    subject { Responder.new(mock("bot")) }
+    before(:all) { class FooMatchMatcher < Matcher; end }
+    it "should add matcher" do
+      subject.should_receive(:add_matcher).with(:foo_match,:bar)
+      subject.foo_match(:bar)
+    end
+    it "should assign callback if block given" do
+      expect { subject.foo_match(:bar) { :baz } }.to change { subject.instance_variable_get(:'@callback') }
+    end
+    it "should return self" do
+      subject.foo_match(:bar).should be subject
+    end
+  end
+
+  describe "#add_matcher" do
+    subject { Responder.new(mock("bot")) }
+    before(:all) { class FooBarMatcher; def initialize(*args); end; end }
+    it "should map matcher name to proper class" do
+      FooBarMatcher.should_receive(:new)
+      subject.send(:add_matcher, :foo_bar, :baz)
+    end
+    it "should add instanciated matcher to matcher chain" do
+      expect { subject.send(:add_matcher, :foo_bar, :baz) }.to change { subject.instance_variable_get(:'@matcher_chain').count }.by(1)
+    end
+  end
+  
+  describe "#callback_with" do
+    subject { Responder.new(mock "bot") }
+    let(:params) { double "params" }
+    after(:each) { subject.callback_with(params) }
+    it "should create callback context" do
+      CallbackContext.should_receive(:new).with(subject, params)
+      subject.instance_variable_set(:"@callback", Proc.new {} )
+    end
+    it "should execute callback in created context" do
+      context = mock("Context", :foo => :bar)
+      CallbackContext.should_receive(:new).and_return(context)
+      context.should_receive(:instance_eval)
+    end
+  end
+  
+  describe "#callback_context" do
+    specify { Responder.new(mock("bot")).send(:callback_context, {}).should be_a CallbackContext }
+  end
+end

data/spec/botfly/responder/subscription_request_responder_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::SubscriptionRequestResponder do
+  it "should be tested"
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 3
-  version: 0.3.3
+  - 4
+  version: 0.3.4
 platform: ruby
 authors: 
 - Ryan Neufeld
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-05 00:00:00 -05:00
+date: 2010-04-10 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -65,6 +65,7 @@ files:
 - example.rb
 - lib/botfly.rb
 - lib/botfly/bot.rb
+- lib/botfly/callback_context.rb
 - lib/botfly/common_block_acceptor.rb
 - lib/botfly/matcher.rb
 - lib/botfly/matcher/body_matcher.rb
@@ -78,13 +79,12 @@ files:
 - 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
 - lib/botfly/responder/subscription_request_responder.rb
 - retrobot.rb
 - spec/botfly/bot_spec.rb
+- spec/botfly/callback_context_spec.rb
 - spec/botfly/common_block_acceptor_spec.rb
 - spec/botfly/matcher/body_matcher_spec.rb
 - spec/botfly/matcher/matcher_spec.rb
@@ -96,9 +96,7 @@ files:
 - spec/botfly/muc_client_spec.rb
 - spec/botfly/responder/common_responder_methods_spec.rb
 - spec/botfly/responder/message_responder_spec.rb
-- spec/botfly/responder/muc_message_responder_spec.rb
 - spec/botfly/responder/muc_responder_spec.rb
-- spec/botfly/responder/presence_responder_spec.rb
 - spec/botfly/responder/responder_spec.rb
 - spec/botfly/responder/subscription_request_responder_spec.rb
 - spec/botfly_spec.rb
@@ -138,6 +136,7 @@ specification_version: 3
 summary: A quick and easy DSL for generating Jabber bots
 test_files: 
 - spec/botfly/bot_spec.rb
+- spec/botfly/callback_context_spec.rb
 - spec/botfly/common_block_acceptor_spec.rb
 - spec/botfly/matcher/body_matcher_spec.rb
 - spec/botfly/matcher/matcher_spec.rb
@@ -149,9 +148,7 @@ test_files:
 - spec/botfly/muc_client_spec.rb
 - spec/botfly/responder/common_responder_methods_spec.rb
 - spec/botfly/responder/message_responder_spec.rb
-- spec/botfly/responder/muc_message_responder_spec.rb
 - spec/botfly/responder/muc_responder_spec.rb
-- spec/botfly/responder/presence_responder_spec.rb
 - spec/botfly/responder/responder_spec.rb
 - spec/botfly/responder/subscription_request_responder_spec.rb
 - spec/botfly_spec.rb

data/lib/botfly/responder/muc_message_responder.rb

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

data/lib/botfly/responder/presence_responder.rb

@@ -1,25 +0,0 @@
-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