tyler-uppercut 0.5.0 → 0.6.1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tyler-uppercut
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors: 
 - Tyler McMullen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-09 00:00:00 -07:00
+date: 2008-11-07 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,7 +21,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-description: Uppercut.  DSL for putting Jabber to work for you.
+description: A DSL for writing agents and notifiers for Jabber.
 email: tbmcmullen@gmail.com
 executables: []
 
@@ -29,24 +29,10 @@ 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
+files: []
+
 has_rdoc: false
-homepage: http://codehallow.com
+homepage: http://github.com/tyler/uppercut
 post_install_message: 
 rdoc_options: []
 
@@ -70,6 +56,6 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: Uppercut.  DSL for putting Jabber to work for you.
+summary: A DSL for writing agents and notifiers for Jabber.
 test_files: []
 

data/LICENSE

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

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

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

@@ -1,21 +0,0 @@
-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.rb

@@ -1,8 +0,0 @@
-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/lib/uppercut/agent.rb

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

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

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

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

@@ -1,32 +0,0 @@
-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/specs/agent_spec.rb

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

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

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

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

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