tyler-uppercut 0.5.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Tyler McMullen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.textile

@@ -0,0 +1,103 @@
+h1. Uppercut
+
+
+h2. Overview
+
+Uppercut is a little DSL for writing agents and notifiers which you interact with via your Jabber client.
+
+
+h2. Making an Agent
+
+You could put together a very simple agent as follows:
+
+<pre>
+  <code>
+    class BasicAgent < Uppercut::Agent
+      command 'date' do |c|
+        m.send `date`
+      end
+  
+      command /^cat (.*)/ do |c,rest|
+        m.send File.read(rest)
+      end
+  
+      command 'report' do |c|
+        m.send 'Hostname: ' + `hostname`
+        m.send 'Running as: ' + ENV['USER']
+      end
+    end
+  </code>
+</pre>
+
+With the above code, we've created an Agent template of sorts.  It responds to three commands: {date cat report}.
+The block which is passed to "command" should always have at least one paramater.  The first parameter will 
+always be an Uppercut::Conversation object, which can be used to respond to the user who sent the input.  When passing
+a regular expression as the first parameter to "command", all of the _captures_ which the pattern match generates
+will also be passed to the block.  This can be seen in the "cat" example above.  There is one capture and it is
+passed in as _rest_.
+
+Then to actually put the Agent to work...
+
+<pre>
+  <code>
+    BasicAgent.new('user@server/resource','password').listen
+  </code>
+</pre>
+
+This creates a new BasicAgent instance and sends it _listen_ to make it start accepting messages.
+Note that by default when an agent is listening, it ignores all errors.  (In the future, I'll have it log them.)
+
+
+h2. Making a Notifier
+
+<pre>
+  <code>
+    class BasicNotifier < Uppercut::Notifier
+      notifier :error do |m,data|
+        m.to 'tbmcmullen@gmail.com'
+        m.send "Something in your app blew up: #{data}"
+      end
+    end
+  </code>
+</pre>
+
+So, we make a new Notifier class and call a _notifier_ block within it.  This makes a notifier with the name :error, which sends a message to tbmcmullen@gmail.com when it fires.
+
+<pre>
+  <code>
+    notifier = BasicNotifier.new('user@server/resource','password').connect
+    
+    notifier.notify :error, 'Sprocket Error!'
+  </code>
+</pre>
+
+The purpose of a Notifier is just to make a multi-purpose event-driven notification system.  You could use it notify yourself of errors in your Rails app, or ping you when a new comment arrives on your blog, or ... I dunno, something else.
+
+I am very aware of how limited this system is at the moment.  I have some big plans for Notifier, so just hang tight while I hack them out...
+
+h2. Todo
+
+
+h3. Security
+
+If you intend to use this on an open Jabber network (read: Google Talk) take some precautions.  Agent#new takes an optional list of JIDs that the agent will respond to.
+
+<pre>
+  <code>
+    BasicAgent.new('user@server/res', 'pw', :roster => ['you@server'])
+  </code>
+</pre>
+
+The agent created with the above statement will not respond to messages or subscription requests from anyone other than 'you@server'.
+
+h3. Features
+
+Uppercut is currently very thin on features, as it's in its infancy.  Here's a brief list of where I'm
+currently intending to take the project:
+
+* send files to and receive files from agents
+* improving the way one writes executables (using the Daemons library is best for the moment)
+* auto-updating of agents
+* I swear I'm going to find a use for MUC
+* allow agents to establish communications on their own, rather than being reactionary (think RSS updates)
+* ... other stuff that sounds fun to code up ...

data/Rakefile

@@ -0,0 +1,71 @@
+# Based on the merb-core Rakefile.  Thanks.
+
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "spec/rake/spectask"
+require "fileutils"
+
+require File.dirname(__FILE__) + "/lib/uppercut"
+
+include FileUtils
+
+NAME = "uppercut"
+
+##############################################################################
+# Packaging & Installation
+##############################################################################
+CLEAN.include ["**/.*.sw?", "pkg", "lib/*.bundle", "*.gem", "doc/rdoc", ".config", "coverage", "cache"]
+
+windows = (PLATFORM =~ /win32|cygwin/) rescue nil
+install_home = ENV['GEM_HOME'] ? "-i #{ENV['GEM_HOME']}" : ""
+
+SUDO = windows ? "" : "sudo"
+
+desc "Packages Uppercut."
+task :default => :package
+
+task :uppercut => [:clean, :rdoc, :package]
+
+spec = eval(File.read(File.join(File.dirname(__FILE__), 'uppercut.gemspec')))
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+end
+
+desc "Run :package and install the resulting .gem"
+task :install => :package do
+  sh %{#{SUDO} gem install #{install_home} --local pkg/#{NAME}-#{Uppercut::VERSION}.gem --no-rdoc --no-ri}
+end
+
+desc "Run :clean and uninstall the .gem"
+task :uninstall => :clean do
+  sh %{#{SUDO} gem uninstall #{NAME}}
+end
+
+##############################################################################
+# Documentation
+##############################################################################
+task :doc => [:rdoc]
+namespace :doc do
+
+  Rake::RDocTask.new do |rdoc|
+    files = ["README", "LICENSE", "CHANGELOG", "lib/**/*.rb"]
+    rdoc.rdoc_files.add(files)
+    rdoc.main = "README"
+    rdoc.title = "Uppercut Docs"
+    rdoc.rdoc_dir = "doc/rdoc"
+    rdoc.options << "--line-numbers" << "--inline-source"
+  end
+
+end
+
+
+##############################################################################
+# Specs
+##############################################################################
+desc "Run all specs"
+Spec::Rake::SpecTask.new('specs') do |t|
+  t.spec_files = FileList['specs/*_spec.rb']
+end

data/examples/basic_agent.rb

@@ -0,0 +1,21 @@
+class BasicAgent < Uppercut::Agent
+  command 'date' do |m|
+    m.send `date`
+  end
+  
+  command /^cat (.*)/ do |m,rest|
+    m.send File.read(rest)
+  end
+  
+  command 'report' do |m|
+    m.send 'Hostname: ' + `hostname`
+    m.send 'Running as: ' + ENV['USER']
+  end
+  
+  command 'dangerous' do |c|
+    c.send "Are you sure?!"
+    c.wait_for do |reply|
+      c.send %w(yes y).include?(reply.downcase) ? "Okay!  Done boss!" : "Cancelled!"
+    end
+  end
+end

data/lib/uppercut/agent.rb

@@ -0,0 +1,145 @@
+class Uppercut
+  class Agent < Base
+    class << self
+      # Define a new command for the agent.
+      # 
+      # The pattern can be a String or a Regexp.  If a String is passed, it
+      # will dispatch this command only on an exact match.  A Regexp simply
+      # must match.
+      #
+      # There is always at least one argument sent to the block.  The first
+      # is a always an Uppercut::Message object, which can be used to reply
+      # to the sender.  The rest of the arguments to the block correspond to
+      # any captures in the pattern Regexp. (Does not apply to String 
+      # patterns).
+      def command(pattern,&block)
+        define_method(gensym) do |msg|
+          return :no_match unless captures = matches?(pattern,msg.body)
+          block[Conversation.new(msg.from,self),*captures]
+        end
+      end
+
+      private
+
+      def gensym
+        '__uc' + (self.instance_methods.grep(/^__uc/).size).to_s.rjust(8,'0')
+      end
+    end
+
+    DEFAULT_OPTIONS = { :connect => true }
+    
+    # Create a new instance of an Agent, possibly connecting to the server.
+    #
+    # user should be a String in the form: "user@server/Resource".  pw is
+    # simply the password for this account.  The final, and optional, argument
+    # is a boolean which controls whether or not it will attempt to connect to
+    # the server immediately.  Defaults to true.
+    def initialize(user,pw,options={})
+      options = DEFAULT_OPTIONS.merge(options)
+      
+      @user = user
+      @pw = pw
+      connect if options[:connect]
+      listen if options[:listen]
+      
+      @allowed_roster = options[:roster]
+      @redirects = {}
+    end
+    
+    
+    def inspect #:nodoc:
+      "<Uppercut::Agent #{@user} " +
+      "#{listening? ? 'Listening' : 'Not Listening'}:" +
+      "#{connected? ? 'Connected' : 'Disconnected'}>"
+    end
+
+    # Makes an Agent instance begin listening for incoming messages and
+    # subscription requests.
+    #
+    # Current listen simply eats any errors that occur, in the interest of
+    # keeping the remote agent alive.  These should be logged at some point
+    # in the future. Pass debug as true to prevent this behaviour.
+    #
+    # Calling listen fires off a new Thread whose sole purpose is to listen
+    # for new incoming messages and then fire off a new Thread which dispatches
+    # the message to the proper handler.
+    def listen(debug=false)
+      connect unless connected?
+
+      @listen_thread = Thread.new {
+        @client.add_message_callback do |message|
+          next if message.body.nil?
+          next unless allowed_roster_includes?(message.from)
+
+          Thread.new do
+            begin
+              dispatch(message)
+            rescue => e
+              log e
+              raise if debug
+            end
+          end
+        end
+        @roster ||= Jabber::Roster::Helper.new(@client)
+        @roster.add_subscription_request_callback do |item,presence|
+          next unless allowed_roster_includes?(presence.from)
+          @roster.accept_subscription(presence.from) 
+        end
+        sleep
+      }
+    end
+
+    # Stops the Agent from listening to incoming messages.
+    #
+    # Simply kills the thread if it is running.
+    def stop
+      @listen_thread.kill if listening?
+    end
+
+    # True if the Agent is currently listening for incoming messages.
+    def listening?
+      @listen_thread && @listen_thread.alive?
+    end
+    
+    def redirect_from(contact,&block)
+      @redirects[contact] ||= []
+      @redirects[contact].push block
+    end
+    
+    attr_accessor :allowed_roster
+
+    private
+
+    def dispatch(msg)
+      block = @redirects[msg.from].respond_to?(:shift) && @redirects[msg.from].shift
+      return block[msg.body] if block
+
+      self.methods.grep(/^__uc/).sort.detect { |m| send(m,msg) != :no_match }
+    end
+
+    def __ucDefault(msg)
+      Message.new(msg.from,self).send("I don't know what \"#{msg.body}\" means.")
+    end
+
+    def matches?(pattern,msg)
+      captures = nil
+      case pattern
+      when String
+        captures = [] if pattern == msg
+      when Regexp
+        match_data = pattern.match(msg)
+        captures = match_data.captures if match_data
+      end
+      captures
+    end
+
+    def allowed_roster_includes?(jid)
+      return true unless @allowed_roster
+      
+      jid = jid.to_s
+      return true if @allowed_roster.include?(jid)
+      return true if @allowed_roster.include?(jid.sub(/\/[^\/]+$/,''))
+    end
+
+  end
+end

data/lib/uppercut/base.rb

@@ -0,0 +1,90 @@
+class Uppercut
+  class Base
+    def stanza(msg) #:nodoc:
+      return false unless connected?
+      send! msg
+    end
+
+    # Attempt to connect to the server, if not already connected.
+    #
+    # Raises a simple RuntimeError if it fails to connect.  This should be
+    # changed eventually to be more useful.
+    def connect
+      return if connected?
+      connect!
+      raise 'Failed to connected' unless connected?
+      present!
+    end
+
+    # Disconnects from the server if it is connected.
+    def disconnect
+      disconnect! if connected?
+    end
+
+    # Disconnects and connects to the server.
+    def reconnect
+      disconnect
+      connect
+    end
+
+    attr_reader :client, :roster
+    
+    # True if the Agent is currently connected to the Jabber server.
+    def connected?
+      @client.respond_to?(:is_connected?) && @client.is_connected?
+    end
+    
+    private
+    
+    def connect!
+      @connect_lock ||= Mutex.new
+      return if @connect_lock.locked?
+      
+      client = Jabber::Client.new(@user)
+      
+      @connect_lock.lock
+
+      client.connect
+      client.auth(@pw)
+      @client = client
+      
+      @connect_lock.unlock
+    end
+
+    def disconnect!
+      @client.close if connected?
+      @client = nil
+    end
+    
+    def present!
+      send! Jabber::Presence.new(nil,"Available")
+    end
+    
+    # Taken directly from xmpp4r-simple (thanks Blaine!)
+    def send!(msg)
+      attempts = 0
+      begin
+        attempts += 1
+        @client.send(msg)
+      rescue Errno::EPIPE, IOError => e
+        sleep 1
+        disconnect!
+        connect!
+        retry unless attempts > 3
+        raise e
+      rescue Errno::ECONNRESET => e
+        sleep (attempts^2) * 60 + 60
+        disconnect!
+        connect!
+        retry unless attempts > 3
+        raise e
+      end
+    end
+
+    def log(error)
+      # todo
+      p error
+    end
+
+  end
+end

data/lib/uppercut/conversation.rb

@@ -0,0 +1,28 @@
+class Uppercut
+  class Conversation < Message
+    attr_reader :to
+
+    def initialize(to,base) #:nodoc:
+      @to = to
+      super base
+    end
+    
+    # Wait for another message from this contact.
+    #
+    # Expects a block which should receive one parameter, which will be a
+    # String.
+    #
+    # One common use of _wait_for_ is for confirmation of a sensitive action.
+    #
+    #     command('foo') do |c|
+    #       c.send 'Are you sure?'
+    #       c.wait_for do |reply|
+    #         do_it if reply.downcase == 'yes'
+    #       end
+    #     end
+    def wait_for(&block)
+      @base.redirect_from(@to,&block)
+    end
+
+  end
+end

data/lib/uppercut/message.rb

@@ -0,0 +1,18 @@
+class Uppercut
+  class Message
+    attr_accessor :to, :message
+
+    def initialize(base) #:nodoc:
+      @base = base
+    end
+
+    # Send a blob of text.
+    def send(body=nil)
+      msg = Jabber::Message.new(@to)
+      msg.type = :chat
+      msg.body = body || @message
+      @base.stanza(msg)
+    end
+  end
+end
+

data/lib/uppercut/notifier.rb

@@ -0,0 +1,32 @@
+class Uppercut
+  class Notifier < Base
+    class << self
+      @@notifiers = {}
+      
+      def notifier(name,&block)
+        @@notifiers[name] = block
+      end
+    end
+
+    def notify(name,data=nil)
+      return false unless connected?
+      @@notifiers[name].call(Message.new(self),data)
+    end
+
+    def initialize(user,pw,options={})
+      options = DEFAULT_OPTIONS.merge(options)
+      
+      @user = user
+      @pw = pw
+      connect if options[:connect]
+    end
+
+    DEFAULT_OPTIONS = { :connect => true }
+    
+    def inspect #:nodoc:
+      "<Uppercut::Notifier #{@user} " +
+      "#{connected? ? 'Connected' : 'Disconnected'}>"
+    end
+
+  end
+end

data/lib/uppercut.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'xmpp4r'
+require 'xmpp4r/roster'
+
+%w(base agent notifier message conversation).each do |mod|
+  require File.join(File.dirname(__FILE__), "uppercut/#{mod}")
+end
+

data/specs/agent_spec.rb

@@ -0,0 +1,176 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Uppercut::Agent do
+  before :each do
+    @agent = TestAgent.new('test@foo.com', 'pw', :connect => false)
+  end
+  
+  describe :new do
+    it "connects by default" do
+      agent = Uppercut::Agent.new('test@foo','pw')
+      agent.should be_connected
+    end
+
+    it "does not connect by default with :connect = false" do
+      agent = Uppercut::Agent.new('test@foo','pw', :connect => false)
+      agent.should_not be_connected
+    end
+    
+    it "starts to listen with :listen = true" do
+      agent = Uppercut::Agent.new('test@foo','pw', :listen => true)
+      agent.should be_listening
+    end
+
+    it "initializes @redirects with a blank hash" do
+      agent = Uppercut::Agent.new('test@foo','pw', :connect => false)
+      agent.instance_eval { @redirects }.should == {}
+    end
+
+    it "populates @pw and @user" do
+      agent = Uppercut::Agent.new('test@foo','pw')
+      agent.instance_eval { @pw }.should == 'pw'
+      agent.instance_eval { @user }.should == 'test@foo'
+    end
+    
+    it "populates @allowed_roster with :roster option" do
+      jids = %w(bob@foo fred@foo)
+      agent = Uppercut::Agent.new('test@foo','pw', :roster => jids)
+      agent.instance_eval { @allowed_roster }.should == jids
+    end
+  end
+  
+  describe :connect do
+    it "does not try to connect if already connected" do
+      @agent.connect
+      old_client = @agent.client
+
+      @agent.connect
+      (@agent.client == old_client).should == true
+    end
+    
+    it "connects if disconnected" do
+      @agent.should_not be_connected
+
+      old_client = @agent.client
+      
+      @agent.connect
+      (@agent.client == old_client).should_not == true
+    end
+    
+    it "sends a Presence notification" do
+      @agent.connect
+      @agent.client.sent.first.class.should == Jabber::Presence
+    end
+  end
+  
+  describe :disconnect do
+    it "does not try to disconnect if not connected" do
+      @agent.client.should be_nil
+      @agent.instance_eval { @client = :foo }
+      
+      @agent.disconnect
+      @agent.client.should == :foo
+    end
+    
+    it "sets @client to nil" do
+      @agent.connect
+      @agent.client.should_not be_nil
+      
+      @agent.disconnect
+      @agent.client.should be_nil
+    end
+  end
+  
+  describe :reconnect do
+    it "calls disconnect then connect" do
+      @agent.should_receive(:disconnect).once.ordered
+      @agent.should_receive(:connect).once.ordered
+
+      @agent.reconnect
+    end
+  end
+  
+  describe :connected? do
+    it "returns true if client#is_connected? is true" do
+      @agent.connect
+      @agent.client.instance_eval { @connected = true }
+      @agent.should be_connected
+    end
+  end
+  
+  describe :listen do
+    it "connects if not connected" do
+      @agent.listen
+      @agent.should be_connected
+    end
+
+    it "spins off a new thread in @listen_thread" do
+      @agent.listen
+      @agent.instance_eval { @listen_thread.class }.should == Thread
+    end
+    
+    it "creates a receive message callback" do
+      @agent.listen
+      @agent.client.on_message.class.should == Proc
+    end
+    
+    it "creates a subscription request callback" do
+      @agent.listen
+      @agent.roster.on_subscription_request.class.should == Proc
+    end
+    
+    it "calls dispatch when receving a message" do
+      @agent.listen
+      @agent.should_receive(:dispatch)
+      @agent.client.receive_message("foo@bar.com","test")
+    end
+  end
+  
+  describe :stop do
+    it "kills the @listen_thread" do
+      @agent.listen
+      @agent.instance_eval { @listen_thread.alive? }.should == true
+      
+      @agent.stop
+      @agent.instance_eval { @listen_thread.alive? }.should_not == true
+    end
+  end
+  
+  describe :listening? do
+    it "returns true if @listen_thread is alive" do
+      @agent.listen
+      @agent.instance_eval { @listen_thread.alive? }.should == true
+      @agent.should be_listening
+    end
+    
+    it "returns false if @listen_thread is not alive" do
+      @agent.listen
+      @agent.stop
+      @agent.should_not be_listening
+    end
+    
+    it "returns false if @listen_thread has not been set" do
+      @agent.should_not be_listening
+    end
+  end
+  
+  describe :dispatch do
+    it "calls the first matching command" do
+      msg = Jabber::Message.new(nil)
+      msg.body = 'hi'
+            
+      @agent.send(:dispatch, msg)
+      @agent.instance_eval { @called_hi_regex }.should_not == true
+      @agent.instance_eval { @called_hi }.should == true
+    end
+    
+    it "matches by regular expression" do
+      msg = Jabber::Message.new(nil)
+      msg.body = 'high'
+      
+      @agent.send(:dispatch, msg)
+      @agent.instance_eval { @called_hi }.should_not == true
+      @agent.instance_eval { @called_hi_regex }.should == true
+    end
+  end
+end

data/specs/conversation_spec.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+describe Uppercut::Conversation do
+  before(:each) do
+    @conv = Uppercut::Conversation.new('test@foo.com', nil)
+  end
+  
+  describe :contact do
+    it "should have a contact method" do
+      @conv.should.respond_to?(:contact)
+    end
+  end
+end

data/specs/jabber_stub.rb

@@ -0,0 +1,76 @@
+Object.send(:remove_const, :Jabber)
+class Jabber
+  class Client
+    def initialize(user)
+      @user = user
+    end
+    
+    def connect
+      @connected = true
+    end
+    
+    def auth(pw)
+      @pw = pw
+    end
+    
+    def is_connected?
+      @connected
+    end
+    
+    def close
+      @connected = nil
+    end
+    
+    attr_reader :sent
+    def send(msg)
+      @sent ||= []
+      @sent << msg
+    end
+    
+    attr_reader :on_message
+    def add_message_callback(&block)
+      @on_message = block
+    end
+    
+    # TESTING HELPER METHODS
+    
+    def receive_message(from,body,type=:chat)
+      msg = Message.new(nil)
+      msg.type = type
+      msg.body = body
+      msg.from = from
+      @on_message[msg]
+    end
+  end
+  
+  class Presence
+    def initialize(a,b)
+    end
+    
+    def from
+    end
+  end
+  
+  class Message
+    attr_accessor :type, :body, :from
+    def initialize(to)
+      @to = to
+    end
+  end
+  
+  class Roster
+    class Helper
+      def initialize(client)
+        @client = client
+      end
+      
+      def accept_subscription(a)
+      end
+   
+      attr_reader :on_subscription_request
+      def add_subscription_request_callback(&block)
+        @on_subscription_request = block
+      end
+    end
+  end
+end

data/specs/notifier_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Uppercut::Notifier do
+  before :each do
+    @notifier = TestNotifier.new('test@foo.com', 'pw', :connect => false)
+  end
+  
+  describe :new do
+    it "connects by default" do
+      notifier = Uppercut::Notifier.new('test@foo','pw')
+      notifier.should be_connected
+    end
+
+    it "does not connect by default with :connect = false" do
+      notifier = Uppercut::Notifier.new('test@foo','pw', :connect => false)
+      notifier.should_not be_connected
+    end
+    
+    it "populates @pw and @user" do
+      notifier = Uppercut::Notifier.new('test@foo','pw')
+      notifier.instance_eval { @pw }.should == 'pw'
+      notifier.instance_eval { @user }.should == 'test@foo'
+    end
+  end
+  
+  describe :connect do
+    it "does not try to connect if already connected" do
+      @notifier.connect
+      old_client = @notifier.client
+
+      @notifier.connect
+      (@notifier.client == old_client).should == true
+    end
+    
+    it "connects if disconnected" do
+      @notifier.should_not be_connected
+
+      old_client = @notifier.client
+      
+      @notifier.connect
+      (@notifier.client == old_client).should_not == true
+    end
+    
+    it "sends a Presence notification" do
+      @notifier.connect
+      @notifier.client.sent.first.class.should == Jabber::Presence
+    end
+  end
+  
+  describe :disconnect do
+    it "does not try to disconnect if not connected" do
+      @notifier.client.should be_nil
+      @notifier.instance_eval { @client = :foo }
+      
+      @notifier.disconnect
+      @notifier.client.should == :foo
+    end
+    
+    it "sets @client to nil" do
+      @notifier.connect
+      @notifier.client.should_not be_nil
+      
+      @notifier.disconnect
+      @notifier.client.should be_nil
+    end
+  end
+  
+  describe :reconnect do
+    it "calls disconnect then connect" do
+      @notifier.should_receive(:disconnect).once.ordered
+      @notifier.should_receive(:connect).once.ordered
+
+      @notifier.reconnect
+    end
+  end
+  
+  describe :connected? do
+    it "returns true if client#is_connected? is true" do
+      @notifier.connect
+      @notifier.client.instance_eval { @connected = true }
+      @notifier.should be_connected
+    end
+  end
+  
+end

data/specs/spec_helper.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'spec'
+require 'set'
+
+$: << File.dirname(__FILE__)
+$: << File.join(File.dirname(__FILE__),'../lib')
+
+# Loads uppercut and jabber
+require 'uppercut'
+
+# Unloads jabber, replacing it with a stub
+require 'jabber_stub'
+
+class TestAgent < Uppercut::Agent
+  command 'hi' do |c|
+    c.instance_eval { @base.instance_eval { @called_hi = true } }
+    c.send 'called hi'
+  end
+  
+  command /^hi/ do |c|
+    c.instance_eval { @base.instance_eval { @called_hi_regex = true } }
+    c.send 'called high regex'
+  end
+  
+  command /(good)?bye/ do |c,good|
+    @called_goodbye = true
+    c.send good ? "Good bye to you as well!" : "Rot!"
+  end
+  
+  command 'wait' do |c|
+    @called_wait = true
+    c.send 'Waiting...'
+    c.wait_for do |reply|
+      @called_wait_block = true
+      c.send 'Hooray!'
+    end
+  end
+end
+
+class TestNotifier < Uppercut::Notifier
+  notifier :foo do |m,data|
+    m.to = 'foo@bar.com'
+    m.send 'Foo happened!'
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: tyler-uppercut
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Tyler McMullen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: xmpp4r
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Uppercut.  DSL for putting Jabber to work for you.
+email: tbmcmullen@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.textile
+- Rakefile
+- lib/uppercut.rb
+- lib/uppercut/agent.rb
+- lib/uppercut/base.rb
+- lib/uppercut/conversation.rb
+- lib/uppercut/message.rb
+- lib/uppercut/notifier.rb
+- specs/agent_spec.rb
+- specs/conversation_spec.rb
+- specs/jabber_stub.rb
+- specs/notifier_spec.rb
+- specs/spec_helper.rb
+- examples/basic_agent.rb
+has_rdoc: false
+homepage: http://codehallow.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Uppercut.  DSL for putting Jabber to work for you.
+test_files: []
+