botfly 0.3.1 → 0.3.2

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.3.2

data/botfly.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{botfly}
-  s.version = "0.3.1"
+  s.version = "0.3.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ryan Neufeld"]
-  s.date = %q{2010-03-28}
+  s.date = %q{2010-04-02}
   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 = [
@@ -45,9 +45,14 @@ Gem::Specification.new do |s|
      "lib/botfly/responder/responder.rb",
      "lib/botfly/responder/subscription_request_responder.rb",
      "retrobot.rb",
+     "spec/botfly/bot_spec.rb",
+     "spec/botfly/common_block_acceptor_spec.rb",
+     "spec/botfly/muc_client_spec.rb",
      "spec/botfly_spec.rb",
      "spec/spec.opts",
-     "spec/spec_helper.rb"
+     "spec/spec_helper.rb",
+     "spec/support/custom_matchers.rb",
+     "spec/support/jabber.rb"
   ]
   s.homepage = %q{http://github.com/rkneufeld/botfly}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -55,8 +60,13 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{A quick and easy DSL for generating Jabber bots}
   s.test_files = [
-    "spec/botfly_spec.rb",
-     "spec/spec_helper.rb"
+    "spec/botfly/bot_spec.rb",
+     "spec/botfly/common_block_acceptor_spec.rb",
+     "spec/botfly/muc_client_spec.rb",
+     "spec/botfly_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/support/custom_matchers.rb",
+     "spec/support/jabber.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/botfly.rb

@@ -14,12 +14,11 @@ require 'botfly/matcher'
 require 'botfly/muc_client'
 
 
-
 Thread.abort_on_exception = true
 
 module Botfly
   def Botfly.logger
-    @logger = Logger.new(@logfile)
+    @logger ||= Logger.new(@logfile)
     return @logger
   end
   def Botfly.login(jid,pass,opts={},logfile=STDOUT,&block)

data/lib/botfly/bot.rb

@@ -2,8 +2,7 @@ require 'rubygems'
 
 module Botfly
   class Bot < CommonBlockAcceptor
-    attr_accessor :responders, :client, :roster, :jid
-    
+    attr_reader :client, :roster, :jid, :host    
     def initialize(jid,pass, opts = {})
       super
       Botfly.logger.info("  BOT: Bot#new")
@@ -23,9 +22,7 @@ module Botfly
       @roster = Jabber::Roster::Helper.new(@client)
       Botfly.logger.info("  BOT: Connected")
       register_for_callbacks
-      @client.send(Jabber::Presence.new.set_status("Carrier has arrived"))
-
-      #Thread.stop
+      self
     end
 
     def join(room_name,&block)
@@ -34,7 +31,7 @@ module Botfly
 
     def quit
       @client.close
-      @main_thread.continue
+      @main_thread.wakeup
     end
 
     def to_debug_s; "BOT"; end
@@ -43,26 +40,23 @@ module Botfly
 
     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_update_callback {|presence| respond_to(:update, :presence => presence) }
       @roster.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|
-        Botfly.logger.debug("    CB: Got Presence")
-        respond_to(:presence, :old => old_presence, :new => new_presence)
+        respond_to(:preesence, :old => old_presence, :new => new_presence)
       end
 
     end
     
     def respond_to(callback_type, params)
-      Botfly.logger.info("  BOT: Responding to callback of type: #{callback_type}")
+      Botfly.logger.info("  BOT: Responding to #{callback_type}")
       @responders[callback_type].each {|r| r.callback_with params} if @responders[callback_type]
     end
   end

data/lib/botfly/common_block_acceptor.rb

@@ -2,18 +2,16 @@ module Botfly
   class CommonBlockAcceptor
     extend Forwardable
 
-    attr_accessor :responders  
-    attr_reader :client
+    attr_reader :block_state, :responders
     
-    def initialize(jid,pass,opts={})
+    def initialize(*ignored)
       @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 respond_to(type,params);  
+      raise "AbstractMethodError: Implement in subclass" 
+    end
 
     def [](key)
       @block_state[key]
@@ -35,18 +33,17 @@ module Botfly
     class OnRecognizer
       def initialize(obj); @obj = obj; end
 
-      def method_missing(type,&block)
+      def method_missing(name,&block)
         Botfly.logger.info("#{@obj.to_debug_s}: Bot#on")
-        type_name = type.to_s.split('_').map(&:capitalize).join('')
-        klass = Botfly.const_get(@obj.class_prefix + type_name + "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")
+        klass = Botfly.const_get(@obj.class_prefix + name.to_s.capitalize + "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
       end
     end
     
-    def class_prefix
-      ''
-    end
+    def class_prefix; ''; end
+    def to_debug_s;   ''; end
+
   end
-end
+end

data/lib/botfly/muc_client.rb

@@ -2,7 +2,7 @@ require 'xmpp4r/muc'
 
 module Botfly
   class MUCClient < CommonBlockAcceptor
-    attr_reader :bot, :muc
+    attr_reader :bot, :muc, :domain, :resource
     
     def room; @block_state; end
     
@@ -26,11 +26,11 @@ module Botfly
       return self
     end
   
-    def leave_room; raise "Implement Me!"; end
+    def leave; @muc.exit; end
     
 
-    def respond_to(callback_type, params)
-      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)
+    def respond_to(callback_type, params={})
+      if (params[:nick] != @resource ) # don't respond to self
         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
@@ -45,8 +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)
+      @muc.join(@jid, nil, :history => false)
       Botfly.logger.info("MUC: Done connecting")
     end
 
@@ -67,4 +66,4 @@ module Botfly
       @muc.on_subject {|time,nick,subject| respond_to(:subject, :time => time, :nick => nick, :subject => subject)}
     end
   end
-end
+end

data/retrobot.rb

@@ -34,21 +34,21 @@ bot = Botfly.login(config["jid"],config["pass"]) do
       
       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]
+    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
 

data/spec/botfly/bot_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include Botfly
+describe Botfly::Bot do
+  context "initializer" do
+    subject { Bot.new('jid','pass', :gtalk => true) }
+    its(:responders) { should be_a Hash }# TODO: This is a really coupled way of checking for super being called
+    context "gtalk option is true" do
+      its(:host) { should == 'talk.google.com' }
+    end
+  end
+
+  context "instance" do
+    subject { Bot.new('jid','pass') }
+    context "readers & accessors" do
+      it { should respond_to :client }
+      it { should respond_to :roster }
+      it { should respond_to :responders }
+      it { should respond_to :host }
+      it { should respond_to :jid }
+    end
+    it { should respond_to :connect }
+    it { should respond_to :join }
+    it { should respond_to :quit }
+    it { should respond_to :[] }
+    it { should respond_to :[]= }
+    it { should respond_to :on }
+    it { should respond_to :remove_responder }
+  end
+
+  describe "#register_for_callbacks" do
+    let(:bot) { Bot.new('jid', 'pass') }
+    before(:each) { stub_jabber_client }
+    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)
+    end
+  end
+
+  describe "#connect" do
+    let(:bot) { Bot.new('jid','pass') }
+    subject { bot }
+    after(:each) { bot.connect }
+    it "should execute methods in order" do
+      bot.client.should_receive(:connect).once.ordered
+      bot.client.should_receive(:auth).once.ordered
+      Jabber::Roster::Helper.should_receive(:new).with(bot.client).once.ordered
+      bot.should_receive(:register_for_callbacks).once.ordered
+    end
+  end
+
+  describe "#quit" do
+    let(:bot) { Bot.new('jid','pass') }
+    after(:each) { bot.quit }
+    specify { bot.client.should_receive(:close) }
+    specify { Thread.current.should_receive(:wakeup) }
+  end
+
+  describe "#join" do
+    let(:bot) { Bot.new('jid','pass') }
+    specify { MUCClient.should_receive(:new).with('foo', bot); bot.join('foo') {} }
+  end
+
+  describe "#respond_to" do
+    let(:bot) { Bot.new('jid', 'params') }
+    let(:responder)  { mock "responder" }
+    let(:responders) { [responder] }
+    before(:each) { bot.responders[:foo] = responders;  }
+    it "should find responders in the responder chain" do
+      bot.responders.should_receive(:[]).with(:foo)
+      bot.send(:respond_to, :foo, :bar)
+    end
+    it "should call #callback_with_params if responder exists for type" do
+      responder.should_receive(:callback_with).with(:bar)
+      bot.send(:respond_to, :foo, :bar)
+    end
+    it "should do nothing if no responder exists for callback" do
+      bot.responders.should_receive(:[]).with(:bar)
+      responder.should_not_receive(:callback_with)
+      bot.send(:respond_to, :bar, :foo)
+    end
+  end
+
+end

data/spec/botfly/common_block_acceptor_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+include Botfly
+describe CommonBlockAcceptor do
+  describe "initialize" do
+    its(:block_state) { should == {} }
+    its(:responders)  { should == {} }
+  end
+
+  context "object" do
+    [:responders, :block_state, :[], :[]=, :on, :remove_responder].each do |m|
+      it { should respond_to m }
+    end
+    describe "#[]" do
+      let(:acceptor) { CommonBlockAcceptor.new }
+      it "should provide hash-like access to block_state" do
+        acceptor[:foo] = :bar
+        acceptor[:foo].should be :bar
+      end
+    end
+  end
+
+  context "abstract method" do
+    let(:acceptor) { CommonBlockAcceptor.new }
+    specify { expect { acceptor.respond_to(nil,nil) }.to raise_error /AbstractMethodError/ }
+  end
+
+  describe '#remove_responder' do
+    let(:acceptor) { CommonBlockAcceptor.new }
+    let(:responder) { stub :id => 1 }
+    before(:each) { acceptor.responders[:foo] = [responder] }
+    it "should remove responder with given id from the chain" do
+      expect { acceptor.remove_responder(1)}.to change { acceptor.responders.values.flatten.count }.to 0 # FIXME: Refactor from Hash to actual ResponderChain object
+    end
+  end
+
+  describe "#class_prefix" do
+    let(:acceptor) { CommonBlockAcceptor.new }
+    its(:class_prefix) { should be_empty }
+  end
+
+  describe "#on" do
+    subject { CommonBlockAcceptor.new.on }
+    it { should be_an CommonBlockAcceptor::OnRecognizer }
+  end
+
+  context "::OnRecognizer" do
+    let(:acceptor) { CommonBlockAcceptor.new }
+    let(:on) { acceptor.on } 
+    before(:each) do
+      class FooResponder; def initialize(bar); end; end
+      class FooBarResponder; def initialize(baz);end; end
+    end
+
+    it "should instanciate responder based on name" do
+      FooResponder.should_receive(:new)
+      on.foo
+    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)
+      on.bar
+    end
+      
+    it "should add responder to object's responder chain hash" do
+      FooResponder.stub(:new).and_return(:foo_instance)
+      acceptor.responders.should == {}
+      expect { on.foo }.to 
+        change { acceptor.responders }.
+          from({}).to({:foo => [:foo_instance]})
+    end
+
+    it "should return the responder itself" do
+      FooResponder.stub(:new).and_return(:foo_instance)
+      on.foo.should be :foo_instance
+    end
+  end
+end
+

data/spec/botfly/muc_client_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+include Botfly
+describe Botfly::MUCClient do
+  let(:jid) { stub("JID", :domain => 'domain.com', :node => 'resource') }
+  let(:bot) { stub("Bot", :client => stub_jabber_client, :jid => jid) }
+  let(:muc) do
+    cbs = [:join, :leave, :message, :room_message, :self_leave, :subject]
+    cbs = cbs.inject({}) { |h,cb| h[:"on_#{cb}"] = nil; h }
+    muc = stub("Jabber::MUC::SimpleMUCClient", cbs.merge(:join => nil))
+    muc
+  end
+  let(:muc_client) { MUCClient.new("Room", bot) { } }
+  context "initializer" do
+    subject { muc_client }
+
+    [:bot, :client, :room, :domain, :resource].each do |ivar|
+      it { should assign ivar }
+    end
+    its(:domain) { should == 'conference.domain.com' }
+    its(:resource) { should == 'resource' }
+    it "should run the passed block" do
+      expect { MUCClient.new("Room", bot) {raise "ran!"} }.to raise_error "ran!"
+    end
+  end
+
+  describe "#room" do
+    it "should expose access to @block_state" do
+      muc_client.room.should == muc_client.instance_variable_get("@block_state")
+    end
+  end
+
+  describe "#execute" do
+    it "should connect before running" do
+      muc_client.should_receive(:connect).ordered
+      muc_client.should_receive(:instance_eval).ordered
+      muc_client.as("foo") {}
+    end
+    it "should execute block" do
+      block = lambda { raise "Ran" }
+      expect { muc_client.send(:execute, &block) }.to raise_error "Ran"
+    end
+
+  end
+
+  describe "#connect" do
+    let(:muc_client) { MUCClient.new("Room", bot) }  
+    after(:each) { muc_client.send(:connect) }
+    it "should complete all steps in order" do
+      Jabber::MUC::SimpleMUCClient.should_receive(:new).ordered.and_return(muc)
+      muc_client.should_receive(:register_for_callbacks).ordered
+      muc.should_receive(:join).ordered
+    end
+  end
+
+  describe "#as" do
+    subject { muc_client }
+    it "should assign resource to given" do
+      muc_client.as(:the_boss)
+      muc_client.resource.should be :the_boss
+    end
+    it "should execute if given a block" do
+      expect { muc_client.as(:foo) { raise "Ran" }}.to raise_error "Ran"
+    end
+  end
+
+  describe "#leave" do
+    it "should leave the chat room" do 
+      muc_client.muc.should_receive(:exit)
+      muc_client.leave
+    end
+  end
+
+  describe "#respond_to" do
+    it "should respond to with appropriate responder" do
+      muc_client.responders[:foo] = [stub("responder", :callback_with => nil)]
+      muc_client.send(:respond_to, :foo)
+    end
+    it "should tell xmpp4r not to send history" do
+      muc.should_receive(:join).with(anything, nil, hash_including(:history => false))
+      Jabber::MUC::SimpleMUCClient.stub(:new).and_return(muc)
+      muc_client.send(:connect)
+    end
+  end
+
+  describe "#register_for_callbacks" do
+    it "should register calls for each callback" do
+      Jabber::MUC::SimpleMUCClient.stub(:new).and_return(muc)
+      [:join, :leave, :message, :room_message, :self_leave, :subject].each do |type|
+        muc.should_receive(:"on_#{type}")
+      end
+      muc_client.send(:register_for_callbacks)
+    end
+  end
+end

data/spec/botfly_spec.rb

@@ -1,7 +1,23 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "Botfly" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
+describe Botfly do
+  describe ".logger" do
+    subject { Botfly.logger }
+    it { should be_a Logger }
+  end
+
+  describe ".login" do
+    it "should connect before evaluation of block" do
+      @bot = mock("bot") 
+      Botfly::Bot.should_receive(:new).and_return(@bot)
+      @bot.should_receive(:connect).ordered.once
+      @bot.should_receive(:instance_exec).ordered.once
+      Botfly.login('jid','pass')
+    end
+    it "should create a new bot" do
+      stub_jabber_client
+      bot = Botfly.login('jid','pass') { }
+      bot.should be_a Botfly::Bot
+    end
   end
 end

data/spec/spec.opts

@@ -1 +1,2 @@
 --color
+--backtrace

data/spec/spec_helper.rb

@@ -3,7 +3,15 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'botfly'
 require 'spec'
 require 'spec/autorun'
+require 'support/jabber'
+require 'support/custom_matchers'
 
 Spec::Runner.configure do |config|
-  
+  Botfly.logger.level = Logger::FATAL
+end
+
+class Object
+  def assigns(name)
+    instance_variable_get("@#{name}")
+  end
 end

data/spec/support/custom_matchers.rb

@@ -0,0 +1,9 @@
+Spec::Matchers.define :assign do |ivar|
+  match do |klass|
+    check_assignment(klass,ivar)
+  end
+  description { "assign to the instance variable @#{ivar}" }
+  def check_assignment(klass,ivar)
+    klass.instance_variable_get("@#{ivar}") != nil
+  end
+end

data/spec/support/jabber.rb

@@ -0,0 +1,8 @@
+def stub_jabber_client
+  client = stub("Jabber::Client",  :connect => nil, 
+                                    :auth => nil,
+                                    :send => nil)
+  def client.method_missing(*args); end
+  Jabber::Client.stub(:new).and_return(client)
+  client
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 1
-  version: 0.3.1
+  - 2
+  version: 0.3.2
 platform: ruby
 authors: 
 - Ryan Neufeld
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-28 00:00:00 -06:00
+date: 2010-04-02 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -82,9 +82,14 @@ files:
 - lib/botfly/responder/responder.rb
 - lib/botfly/responder/subscription_request_responder.rb
 - retrobot.rb
+- spec/botfly/bot_spec.rb
+- spec/botfly/common_block_acceptor_spec.rb
+- spec/botfly/muc_client_spec.rb
 - spec/botfly_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/support/custom_matchers.rb
+- spec/support/jabber.rb
 has_rdoc: true
 homepage: http://github.com/rkneufeld/botfly
 licenses: []
@@ -116,5 +121,10 @@ signing_key:
 specification_version: 3
 summary: A quick and easy DSL for generating Jabber bots
 test_files: 
+- spec/botfly/bot_spec.rb
+- spec/botfly/common_block_acceptor_spec.rb
+- spec/botfly/muc_client_spec.rb
 - spec/botfly_spec.rb
 - spec/spec_helper.rb
+- spec/support/custom_matchers.rb
+- spec/support/jabber.rb