sprsquish-blather 0.3.0 → 0.3.1

data/README.rdoc

@@ -60,7 +60,7 @@ Guards act like AND statements. Each condition must be met if the handler is to
   # Equivalent to saying (stanza.chat? && stanza.body)
   message :chat?, :body
 
-There are 5 different types of guards:
+The different types of guards are:
 
   # Symbol
   #   Checks for a non-false reply to calling the symbol on the stanza
@@ -93,9 +93,24 @@ There are 5 different types of guards:
   #   Equivalent to stanza.body == 'foo' || stanza.body == 'baz'
   message [{:body => 'foo'}, {:body => 'baz'}]
 
+== On the Command Line:
+
+Default usage is:
+
+  [blather_script] [options] node@domain.com/resource password [host] [port]
+
+Command line options:
+
+  -D, --debug                      Run in debug mode (you will see all XMPP communication)
+  -d, --daemonize                  Daemonize the process
+      --pid=[PID]                  Write the PID to this file
+      --log=[LOG]                  Write to the [LOG] file instead of stdout/stderr
+  -h, --help                       Show this message
+  -v, --version                    Show version
+
+
 = TODO
 
-* Better Documentation
 * Add XPath guard that passes the result to the handler
 * Add Disco the the DSL
 * PubSub (XEP-0060: http://xmpp.org/extensions/xep-0060.html)

data/Rakefile

@@ -16,7 +16,7 @@ begin
     gem.extensions = ['Rakefile']
 
     gem.add_dependency 'eventmachine', '>= 0.12.6'
-    gem.add_dependency 'libxml-ruby', '>= 1.1.3'
+    gem.add_dependency 'libxml-ruby', '>= 1.1.2'
 
     gem.files = FileList['examples/**/*', 'lib/**/*', 'ext/*.{rb,c}'].to_a
 

data/examples/ping_pong.rb

@@ -0,0 +1,37 @@
+require 'blather/client/dsl'
+$stdout.sync = true
+
+module Ping
+  extend Blather::DSL
+  def self.run; client.run; end
+
+  setup 'echo@jabber.local/ping', 'echo'
+
+  status :from => Blather::JID.new('echo@jabber.local/pong') do |s|
+    puts "serve!"
+    say s.from, 'ping'
+  end
+
+  message :chat?, :body => 'pong' do |m|
+    puts "ping!"
+    say m.from, 'ping'
+  end
+end
+
+module Pong
+  extend Blather::DSL
+  def self.run; client.run; end
+
+  setup 'echo@jabber.local/pong', 'echo'
+  message :chat?, :body => 'ping' do |m|
+    puts "pong!"
+    say m.from, 'pong'
+  end
+end
+
+trap(:INT) { EM.stop }
+trap(:TERM) { EM.stop }
+EM.run do
+  Ping.run
+  Pong.run
+end

data/lib/blather.rb

@@ -1,6 +1,3 @@
-$:.unshift File.dirname(__FILE__)
-$:.unshift File.join(File.dirname(__FILE__), '..')
-
 # Require the necessary files
 %w[
   rubygems
@@ -48,6 +45,6 @@ $:.unshift File.join(File.dirname(__FILE__), '..')
 XML.indent_tree_output = false
 
 module Blather
-  LOG = Logger.new(STDOUT) unless const_defined?(:LOG)
+  LOG = Logger.new($stdout) unless const_defined?(:LOG)
   LOG.level = Logger::INFO
 end

data/lib/blather/client.rb

@@ -1,13 +1,85 @@
+require 'optparse'
 require File.join(File.dirname(__FILE__), *%w[client dsl])
 
 include Blather::DSL
 
+options = {}
+optparse = OptionParser.new do |opts|
+  opts.banner = "Run with #{$0} [options] user@server/resource password [host] [port]"
+
+  opts.on('-D', '--debug', 'Run in debug mode (you will see all XMPP communication)') do |debug|
+    options[:debug] = debug
+  end
+
+  opts.on('-d', '--daemonize', 'Daemonize the process') do |daemonize|
+    options[:daemonize] = daemonize
+  end
+
+  opts.on('--pid=[PID]', 'Write the PID to this file') do |pid|
+    if !File.writable?(File.dirname(pid))
+      $stderr.puts "Unable to write log file to #{pid}"
+      exit 1
+    end
+    options[:pid] = pid
+  end
+
+  opts.on('--log=[LOG]', 'Write to the [LOG] file instead of stdout/stderr') do |log|
+    if !File.writable?(File.dirname(log))
+      $stderr.puts "Unable to write log file to #{log}"
+      exit 1
+    end
+    options[:log] = log
+  end
+
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts
+    exit
+  end
+
+  opts.on_tail('-v', '--version', 'Show version') do
+    require 'yaml'
+    version = YAML.load_file File.join(File.dirname(__FILE__), %w[.. .. VERSION.yml])
+    puts "Blather v#{version[:major]}.#{version[:minor]}.#{version[:patch]}"
+    exit
+  end
+end
+optparse.parse!
+
 at_exit do
   unless client.setup?
     if ARGV.length < 2
-      puts "Run with #{$0} user@server/resource password [host] [port]"
-    else
-      client.setup(*ARGV).run
+      puts optparse
+      exit 1
+    end
+    client.setup(*ARGV)
+  end
+
+  def run(options)
+    $stdin.reopen "/dev/null"
+
+    if options[:log]
+      log = File.new(options[:log], 'a')
+      log.sync = options[:debug]
+      Blather::LOG.level = Logger::DEBUG if options[:debug]
+      $stdout.reopen log
+      $stderr.reopen $stdout
+    end
+    trap(:INT) { EM.stop }
+    trap(:TERM) { EM.stop }
+    EM.run { client.run }
+  end
+
+  if options[:daemonize]
+    pid = fork do
+      Process.setsid
+      exit if fork
+      File.open(options[:pid], 'w') { |f| f << Process.pid } if options[:pid]
+      run options
+      FileUtils.rm(options[:pid]) if options[:pid]
     end
+    ::Process.detach pid
+    exit
+  else
+    run options
   end
 end

data/lib/blather/client/client.rb

@@ -3,8 +3,8 @@ require File.join(File.dirname(__FILE__), *%w[.. .. blather])
 module Blather #:nodoc:
 
   class Client #:nodoc:
-    attr_accessor :jid,
-                  :roster
+    attr_reader :jid,
+                :roster
 
     def initialize
       @state = :initializing
@@ -17,6 +17,24 @@ module Blather #:nodoc:
       setup_initial_handlers
     end
 
+    def jid=(new_jid)
+      @jid = JID.new new_jid
+    end
+
+    def status
+      @status.state
+    end
+
+    def status=(state)
+      state, msg, to = state
+
+      status = Stanza::Presence::Status.new state, msg
+      status.to = to
+      @status = status unless to
+
+      write status
+    end
+
     def setup?
       @setup.is_a? Array
     end
@@ -30,11 +48,8 @@ module Blather #:nodoc:
 
     def run
       raise 'not setup!' unless setup?
-      trap(:INT) { EM.stop }
-      EM.run {
-        klass = @setup[0].node ? Blather::Stream::Client : Blather::Stream::Component
-        klass.start self, *@setup
-      }
+      klass = @setup[0].node ? Blather::Stream::Client : Blather::Stream::Component
+      @stream = klass.start self, *@setup
     end
 
     def register_tmp_handler(id, &handler)
@@ -42,62 +57,38 @@ module Blather #:nodoc:
     end
 
     def register_handler(type, *guards, &handler)
+      check_guards guards
       @handlers[type] ||= []
       @handlers[type] << [guards, handler]
     end
 
-    def status
-      @status.state
-    end
-
-    def status=(state)
-      state, msg, to = state
-
-      status = Stanza::Presence::Status.new state, msg
-      status.to = to
-      @status = status unless to
-
-      write status
-    end
-
     def write(stanza)
       stanza.from ||= jid if stanza.respond_to?(:from)
       @stream.send(stanza) if @stream
     end
 
-    def write_with_handler(stanza, &hanlder)
+    def write_with_handler(stanza, &handler)
       register_tmp_handler stanza.id, &handler
       write stanza
     end
 
-    def stream_started(stream)
-      @stream = stream
-
-      #retreive roster
-      if @stream.is_a?(Stream::Component)
-        @state = :ready
-        call_handler_for :ready, nil
-      else
-        r = Stanza::Iq::Roster.new
-        register_tmp_handler r.id do |node|
-          roster.process node
-          @state = :ready
-          write @status
-          call_handler_for :ready, nil
-        end
-        write r
+    def post_init
+      case @stream
+      when Stream::Component  then ready!
+      when Stream::Client     then client_post_init
+      else                    raise "Don't know #{@stream.class} stream type. How the hell did this happen!?"
       end
     end
 
-    def stop
+    def close
       @stream.close_connection_after_writing
     end
 
-    def stopped
-      EM.stop
+    def unbind
+      EM.stop if EM.reactor_running?
     end
 
-    def call(stanza)
+    def receive_data(stanza)
       if handler = @tmp_handlers.delete(stanza.id)
         handler.call stanza
       else
@@ -107,21 +98,14 @@ module Blather #:nodoc:
       end
     end
 
-    def call_handler_for(type, stanza)
-      if @handlers[type]
-        @handlers[type].find { |guards, handler| handler.call(stanza) unless guarded?(guards, stanza) }
-        true
-      end
-    end
-
   protected
     def setup_initial_handlers
       register_handler :error do |err|
         raise err
       end
 
-      register_handler :iq do |iq|
-        write(StanzaError.new(iq, 'service-unavailable', :cancel).to_node) if [:set, :get].include?(iq.type)
+      register_handler :iq, :type => [:get, :set] do |iq|
+        write(StanzaError.new(iq, 'service-unavailable', :cancel).to_node)
       end
 
       register_handler :status do |status|
@@ -133,8 +117,30 @@ module Blather #:nodoc:
       end
     end
 
+    def ready!
+      @state = :ready
+      call_handler_for :ready, nil
+    end
+
+    def client_post_init
+      write_with_handler Stanza::Iq::Roster.new do |node|
+        roster.process node
+        write @status
+        ready!
+      end
+    end
+
+    def call_handler_for(type, stanza)
+      if @handlers[type]
+        @handlers[type].find { |guards, handler| handler.call(stanza) unless guarded?(guards, stanza) }
+        true
+      end
+    end
+
     ##
     # If any of the guards returns FALSE this returns true
+    # the logic is reversed to allow short circuiting
+    # (why would anyone want to loop over more values than necessary?)
     def guarded?(guards, stanza)
       guards.find do |guard|
         case guard
@@ -158,8 +164,16 @@ module Blather #:nodoc:
           end
         when Proc
           !guard.call(stanza)
-        else
-          raise "Bad guard: #{guard.inspect}"
+        end
+      end
+    end
+
+    def check_guards(guards)
+      guards.each do |guard|
+        case guard
+        when Array              then guard.each { |g| check_guards([g]) }
+        when Symbol, Proc, Hash then nil
+        else                    raise "Bad guard: #{guard.inspect}"
         end
       end
     end

data/lib/blather/client/dsl.rb

@@ -13,14 +13,13 @@ module Blather
     # host and port are optional defaulting to the domain in the JID and 5222 respectively
     def setup(jid, password, host = nil, port = nil)
       client.setup(jid, password, host, port)
-      at_exit { client.run }
     end
 
     ##
     # Shutdown the connection.
     # Flushes the write buffer then stops EventMachine
     def shutdown
-      client.stop
+      client.close
     end
 
     ##
@@ -37,13 +36,13 @@ module Blather
 
     ##
     # Set current status
-    def status(state = nil, msg = nil)
+    def set_status(state = nil, msg = nil)
       client.status = state, msg
     end
 
     ##
     # Direct access to the roster
-    def roster
+    def my_roster
       client.roster
     end
 
@@ -51,7 +50,7 @@ module Blather
     # Write data to the stream
     # Anything that resonds to #to_s can be paseed to the stream
     def write(stanza)
-      client.write(stanza)
+      client.write stanza
     end
 
     ##
@@ -68,7 +67,9 @@ module Blather
     end
 
     ##
-    #
+    # Request items or info from an entity
+    #   discover (items|info), [jid], [node] do |response|
+    #   end
     def discover(what, who, where, &callback)
       stanza = Blather::Stanza.class_from_registration(:query, "http://jabber.org/protocol/disco##{what}").new
       stanza.to = who
@@ -78,22 +79,16 @@ module Blather
       write stanza
     end
 
-    ##
-    # PubSub proxy
-    def pubsub
-      client.pubsub
-    end
-
     ##
     # Checks to see if the method is part of the handlers list.
     # If so it creates a handler, otherwise it'll pass it back
     # to Ruby's method_missing handler
-    def method_missing(method, *args, &block)
-      if Blather::Stanza.handler_list.include?(method)
-        handle method, *args, &block
-      else
-        super
-      end
+    Blather::Stanza.handler_list.each do |handler_name|
+      module_eval <<-METHOD, __FILE__, __LINE__
+        def #{handler_name}(*args, &callback)
+          handle :#{handler_name}, *args, &callback
+        end
+      METHOD
     end
   end #DSL
 end #Blather

data/lib/blather/stanza/disco/disco_info.rb

@@ -52,13 +52,6 @@ class Stanza
           self.category = category
         end
       end
-
-      def eql?(other)
-        other.kind_of?(self.class) &&
-        other.name == self.name &&
-        other.type == self.type &&
-        other.category == self.category
-      end
     end
 
     class Feature < XMPPNode
@@ -72,11 +65,6 @@ class Stanza
           self.var = var
         end
       end
-
-      def eql?(other)
-        other.kind_of?(self.class) &&
-        other.var == self.var
-      end
     end
   end
 

data/lib/blather/stanza/disco/disco_items.rb

@@ -46,13 +46,6 @@ class Stanza
 
       attribute_accessor :node, :name, :to_sym => false      
     end
-
-    def eql?(other)
-      other.kind_of?(self.class) &&
-      other.jid == self.jid &&
-      other.node == self.node &&
-      other.name == self.name
-    end
   end
 
 end #Stanza

data/lib/blather/stream.rb

@@ -87,8 +87,8 @@ module Blather
     def unbind # :nodoc:
 #      @keepalive.cancel
       @state = :stopped
-      @client.call @error if @error
-      @client.stopped
+      @client.receive_data @error if @error
+      @client.unbind
     end
 
     ##
@@ -162,7 +162,7 @@ module Blather
     # Called when @state == :ready
     #   Simply passes the stanza to the client
     def ready
-      @client.call @node.to_stanza
+      @client.receive_data @node.to_stanza
     end
 
     def handle_stream_error
@@ -242,7 +242,7 @@ module Blather
         @session = Session.new self, @to
         # on success destroy the session object, let the client know the stream has been started
         # then continue the features dispatch process
-        @session.on_success { LOG.debug "SESSION: SUCCESS"; @session = nil; @client.stream_started(self); @state = :features; dispatch }
+        @session.on_success { LOG.debug "SESSION: SUCCESS"; @session = nil; @client.post_init; @state = :features; dispatch }
         # on failure end the stream
         @session.on_failure { |err| LOG.debug "SESSION: FAILURE"; @error = err; stop }
 

data/lib/blather/stream/component.rb

@@ -6,7 +6,7 @@ class Stream
 
     def receive(node) # :nodoc:
       if node.element_name == 'handshake'
-        @client.stream_started(self)
+        @client.post_init
       else
         super
       end

data/spec/blather/client/client_spec.rb

@@ -0,0 +1,389 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+require 'blather/client/client'
+
+describe 'Blather::Client' do
+  before do
+    @client = Blather::Client.new
+  end
+
+  it 'provides a JID accessor' do
+    @client.must_respond_to :jid
+    @client.jid.must_be_nil
+
+    jid = 'me@me.com/test'
+    @client.must_respond_to :jid=
+    @client.jid = jid
+    @client.jid.must_be_kind_of JID
+    @client.jid.must_equal JID.new(jid)
+  end
+
+  it 'provides a reader for the roster' do
+    @client.must_respond_to :roster
+    @client.roster.must_be_kind_of Roster
+  end
+
+  it 'provides a status reader' do
+    @client.must_respond_to :status
+    @client.status = :away
+    @client.status.must_equal :away
+  end
+
+  it 'can be setup' do
+    @client.must_respond_to :setup
+    @client.setup('me@me.com', 'pass').must_equal @client
+  end
+
+  it 'knows if it has been setup' do
+    @client.must_respond_to :setup?
+    @client.setup?.must_equal false
+    @client.setup 'me@me.com', 'pass'
+    @client.setup?.must_equal true
+  end
+
+  it 'cannot be run before being setup' do
+    lambda { @client.run }.must_raise RuntimeError
+  end
+
+  it 'starts up a Component connection when setup without a node' do
+    setup = 'pubsub.jabber.local', 'secret'
+    @client.setup *setup
+    Blather::Stream::Component.expects(:start).with @client, *setup
+    @client.run
+  end
+
+  it 'starts up a Client connection when setup with a node' do
+    setup = 'test@jabber.local', 'secret'
+    @client.setup *setup
+    Blather::Stream::Client.expects(:start).with @client, *setup
+    @client.run
+  end
+
+  it 'writes to the connection the closes when #close is called' do
+    stream = mock()
+    stream.expects(:close_connection_after_writing)
+    Blather::Stream::Component.stubs(:start).returns stream
+    @client.setup('me.com', 'secret').run
+    @client.close
+  end
+
+  it 'shuts down EM when #unbind is called if it is running' do
+    EM.expects(:reactor_running?).returns true
+    EM.expects(:stop)
+    @client.unbind
+  end
+
+  it 'does nothing when #unbind is called and EM is not running' do
+    EM.expects(:reactor_running?).returns false
+    EM.expects(:stop).never
+    @client.unbind
+  end
+
+  it 'raises an error if the stream type somehow is not supported' do
+    Blather::Stream::Component.stubs(:start).returns nil
+    @client.setup('me.com', 'secret').run
+    lambda { @client.post_init }.must_raise RuntimeError
+  end
+
+  it 'can register a temporary handler based on stanza ID' do
+    stanza = Stanza::Iq.new
+    response = mock()
+    response.expects(:call)
+    @client.register_tmp_handler(stanza.id) { |_| response.call }
+    @client.receive_data stanza
+  end
+
+  it 'removes a tmp handler as soon as it is used' do
+    stanza = Stanza::Iq.new
+    response = mock()
+    response.expects(:call)
+    @client.register_tmp_handler(stanza.id) { |_| response.call }
+    @client.receive_data stanza
+    @client.receive_data stanza
+  end
+
+  it 'will create a handler then write the stanza' do
+    stanza = Stanza::Iq.new
+    response = mock()
+    response.expects(:call)
+    @client.expects(:write).with do |s|
+      @client.receive_data stanza
+      s.must_equal stanza
+    end
+    @client.write_with_handler(stanza) { |_| response.call }
+  end
+
+  it 'can register a handler' do
+    stanza = Stanza::Iq.new
+    response = mock()
+    response.expects(:call).times(2)
+    @client.register_handler(:iq) { |_| response.call }
+    @client.receive_data stanza
+    @client.receive_data stanza
+  end
+end
+
+describe 'Blather::Client#write' do
+  before do
+    @client = Blather::Client.new
+  end
+
+  it 'sets the from attr on a stanza' do
+    jid = 'me@me.com'
+    stanza = mock(:from => nil)
+    stanza.expects(:from=).with jid
+    @client.jid = jid
+    @client.write stanza
+  end
+
+  it 'does not set the from attr if it already exists' do
+    jid = 'me@me.com'
+    stanza = Stanza::Iq.new
+    stanza.from = jid
+    stanza.expects(:from).returns jid
+    stanza.expects(:from=).never
+    @client.jid = jid
+    @client.write stanza
+  end
+
+  it 'writes to the stream' do
+    stanza = Stanza::Iq.new
+    stream = mock()
+    stream.expects(:send).with stanza
+    Blather::Stream::Client.expects(:start).returns stream
+    @client.setup('me@me.com', 'me').run
+    @client.write stanza
+  end
+end
+
+describe 'Blather::Client#status=' do
+  before do
+    @client = Blather::Client.new
+  end
+
+  it 'updates the state when not sending to a JID' do
+    @client.status.wont_equal :away
+    @client.status = :away, 'message'
+    @client.status.must_equal :away
+  end
+
+  it 'does not update the state when sending to a JID' do
+    @client.status.wont_equal :away
+    @client.status = :away, 'message', 'me@me.com'
+    @client.status.wont_equal :away
+  end
+
+  it 'writes the new status to the stream' do
+    Stanza::Presence::Status.stubs(:next_id).returns 0
+    status = [:away, 'message']
+    @client.expects(:write).with do |s|
+      s.must_be_kind_of Stanza::Presence::Status
+      s.to_s.must_equal Stanza::Presence::Status.new(*status).to_s
+    end
+    @client.status = status
+  end
+end
+
+describe 'Blather::Client default handlers' do
+  before do
+    @client = Blather::Client.new
+  end
+
+  it 're-raises errors' do
+    err = BlatherError.new
+    lambda { @client.receive_data err }.must_raise BlatherError
+  end
+
+  it 'responds to iq:get with a "service-unavailable" error' do
+    get = Stanza::Iq.new :get
+    err = StanzaError.new(get, 'service-unavailable', :cancel).to_node
+    @client.expects(:write).with err
+    @client.receive_data get
+  end
+
+  it 'responds to iq:get with a "service-unavailable" error' do
+    get = Stanza::Iq.new :get
+    err = StanzaError.new(get, 'service-unavailable', :cancel).to_node
+    @client.expects(:write).with err
+    @client.receive_data get
+  end
+
+  it 'responds to iq:set with a "service-unavailable" error' do
+    get = Stanza::Iq.new :set
+    err = StanzaError.new(get, 'service-unavailable', :cancel).to_node
+    @client.expects(:write).with err
+    @client.receive_data get
+  end
+
+  it 'handles status changes by updating the roster if the status is from a JID in the roster' do
+    jid = 'friend@jabber.local'
+    status = Stanza::Presence::Status.new :away
+    status.stubs(:from).returns jid
+    roster_item = mock()
+    roster_item.expects(:status=).with status
+    @client.stubs(:roster).returns({status.from => roster_item})
+    @client.receive_data status
+  end
+
+  it 'handles an incoming roster node by processing it through the roster' do
+    roster = Stanza::Iq::Roster.new
+    client_roster = mock()
+    client_roster.expects(:process).with roster
+    @client.stubs(:roster).returns client_roster
+    @client.receive_data roster
+  end
+end
+
+describe 'Blather::Client with a Component stream' do
+  before do
+    class MockComponent < Blather::Stream::Component; def initialize(); end; end
+    @client = Blather::Client.new 
+    Blather::Stream::Component.stubs(:start).returns MockComponent.new('')
+    @client.setup('me.com', 'secret').run
+  end
+
+  it 'calls the ready handler when sent post_init' do
+    ready = mock()
+    ready.expects(:call)
+    @client.register_handler(:ready) { ready.call }
+    @client.post_init
+  end
+end
+
+describe 'Blather::Client with a Client stream' do
+  before do
+    class MockClientStream < Blather::Stream::Client; def initialize(); end; end
+    @stream = MockClientStream.new('')
+    @client = Blather::Client.new 
+    Blather::Stream::Client.stubs(:start).returns @stream
+    @client.setup('me@me.com', 'secret').run
+  end
+
+  it 'sends a request for the roster when post_init is called' do
+    @stream.expects(:send).with { |stanza| stanza.must_be_kind_of Stanza::Iq::Roster }
+    @client.post_init
+  end
+
+  it 'calls the ready handler after post_init and roster is received' do
+    result_roster = Stanza::Iq::Roster.new :result
+    @stream.stubs(:send).with { |s| result_roster.id = s.id; @client.receive_data result_roster; true }
+
+    ready = mock()
+    ready.expects(:call)
+    @client.register_handler(:ready) { ready.call }
+    @client.post_init
+  end
+end
+
+describe 'Blather::Client guards' do
+  before do
+    @client = Blather::Client.new
+    @stanza = Stanza::Iq.new
+    @response = mock()
+  end
+
+  it 'can be a symbol' do
+    @response.expects :call
+    @client.register_handler(:iq, :chat?) { |_| @response.call }
+
+    @stanza.expects(:chat?).returns true
+    @client.receive_data @stanza
+
+    @stanza.expects(:chat?).returns false
+    @client.receive_data @stanza
+  end
+
+  it 'can be a hash with string match' do
+    @response.expects :call
+    @client.register_handler(:iq, :body => 'exit') { |_| @response.call }
+
+    @stanza.expects(:body).returns 'exit'
+    @client.receive_data @stanza
+
+    @stanza.expects(:body).returns 'not-exit'
+    @client.receive_data @stanza
+  end
+
+  it 'can be a hash with a value' do
+    @response.expects :call
+    @client.register_handler(:iq, :number => 0) { |_| @response.call }
+
+    @stanza.expects(:number).returns 0
+    @client.receive_data @stanza
+
+    @stanza.expects(:number).returns 1
+    @client.receive_data @stanza
+  end
+
+  it 'can be a hash with a regexp' do
+    @response.expects :call
+    @client.register_handler(:iq, :body => /exit/) { |_| @response.call }
+
+    @stanza.expects(:body).returns 'more than just exit, but exit still'
+    @client.receive_data @stanza
+
+    @stanza.expects(:body).returns 'keyword not found'
+    @client.receive_data @stanza
+  end
+
+  it 'can be a hash with an array' do
+    @response.expects(:call).times(2)
+    @client.register_handler(:iq, :type => [:result, :error]) { |_| @response.call }
+
+    stanza = Stanza::Iq.new
+    stanza.expects(:type).at_least_once.returns :result
+    @client.receive_data stanza
+
+    stanza = Stanza::Iq.new
+    stanza.expects(:type).at_least_once.returns :error
+    @client.receive_data stanza
+
+    stanza = Stanza::Iq.new
+    stanza.expects(:type).at_least_once.returns :get
+    @client.receive_data stanza
+  end
+
+  it 'chained are treated like andand (short circuited)' do
+    @response.expects :call
+    @client.register_handler(:iq, :type => :get, :body => 'test') { |_| @response.call }
+
+    stanza = Stanza::Iq.new
+    stanza.expects(:type).at_least_once.returns :get
+    stanza.expects(:body).returns 'test'
+    @client.receive_data stanza
+
+    stanza = Stanza::Iq.new
+    stanza.expects(:type).at_least_once.returns :set
+    stanza.expects(:body).never
+    @client.receive_data stanza
+  end
+
+  it 'within an Array are treated as oror (short circuited)' do
+    @response.expects(:call).times 2
+    @client.register_handler(:iq, [{:type => :get}, {:body => 'test'}]) { |_| @response.call }
+
+    stanza = Stanza::Iq.new
+    stanza.expects(:type).at_least_once.returns :set
+    stanza.expects(:body).returns 'test'
+    @client.receive_data stanza
+
+    stanza = Stanza::Iq.new
+    stanza.stubs(:type).at_least_once.returns :get
+    stanza.expects(:body).never
+    @client.receive_data stanza
+  end
+
+  it 'can be a lambda' do
+    @response.expects :call
+    @client.register_handler(:iq, lambda { |s| s.number % 3 == 0 }) { |_| @response.call }
+
+    @stanza.expects(:number).at_least_once.returns 3
+    @client.receive_data @stanza
+
+    @stanza.expects(:number).at_least_once.returns 2
+    @client.receive_data @stanza
+  end
+
+  it 'raises an error when a bad guard is tried' do
+    lambda { @client.register_handler(:iq, 0) {} }.must_raise RuntimeError
+  end
+end

data/spec/blather/client/dsl_spec.rb

@@ -0,0 +1,105 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+require 'blather/client/dsl'
+
+describe 'Blather::DSL' do
+  before do
+    @client = mock()
+    @dsl = class MockDSL; include Blather::DSL; end.new
+    Client.stubs(:new).returns(@client)
+  end
+
+  it 'wraps the setup' do
+    args = ['jid', 'pass', 'host', 0000]
+    @client.expects(:setup).with *args
+    @dsl.setup *args
+  end
+
+  it 'allows host to be nil in setup' do
+    args = ['jid', 'pass']
+    @client.expects(:setup).with *(args + [nil, nil])
+    @dsl.setup *args
+  end
+
+  it 'allows port to be nil in setup' do
+    args = ['jid', 'pass', 'host']
+    @client.expects(:setup).with *(args + [nil])
+    @dsl.setup *args
+  end
+
+  it 'stops when shutdown is called' do
+    @client.expects(:close)
+    @dsl.shutdown
+  end
+
+  it 'sets up handlers' do
+    type = :message
+    guards = [:chat?, {:body => 'exit'}]
+    @client.expects(:register_handler).with type, *guards
+    @dsl.handle type, *guards
+  end
+
+  it 'provides a helper for ready state' do
+    @client.expects(:register_handler).with :ready
+    @dsl.when_ready
+  end
+
+  it 'sets the initial status' do
+    state = :away
+    msg = 'do not disturb'
+    @client.expects(:status=).with [state, msg]
+    @dsl.set_status state, msg
+  end
+
+  it 'provides a roster accessor' do
+    @client.expects :roster
+    @dsl.my_roster
+  end
+
+  it 'provides a writer' do
+    stanza = Blather::Stanza::Iq.new
+    @client.expects(:write).with stanza
+    @dsl.write stanza
+  end
+
+  it 'provides a "say" helper' do
+    to, msg = 'me@me.com', 'hello!'
+    Blather::Stanza::Message.stubs(:next_id).returns 0
+    @client.expects(:write).with Blather::Stanza::Message.new(to, msg)
+    @dsl.say to, msg
+  end
+
+  it 'provides a JID accessor' do
+    @client.expects :jid
+    @dsl.jid
+  end
+
+  it 'provides a disco helper for items' do
+    what, who, where = :items, 'me@me.com', 'my/node'
+    Blather::Stanza::Disco::DiscoItems.stubs(:next_id).returns 0
+    @client.expects(:temporary_handler).with '0'
+    expected_stanza = Blather::Stanza::Disco::DiscoItems.new
+    expected_stanza.to = who
+    expected_stanza.node = where
+    @client.expects(:write).with expected_stanza
+    @dsl.discover what, who, where
+  end
+
+  it 'provides a disco helper for info' do
+    what, who, where = :info, 'me@me.com', 'my/node'
+    Blather::Stanza::Disco::DiscoInfo.stubs(:next_id).returns 0
+    @client.expects(:temporary_handler).with '0'
+    expected_stanza = Blather::Stanza::Disco::DiscoInfo.new
+    expected_stanza.to = who
+    expected_stanza.node = where
+    @client.expects(:write).with expected_stanza
+    @dsl.discover what, who, where
+  end
+
+  Blather::Stanza.handler_list.each do |handler_method|
+    it "provides a helper method for #{handler_method}" do
+      guards = [:chat?, {:body => 'exit'}]
+      @client.expects(:register_handler).with handler_method, *guards
+      @dsl.__send__(handler_method, *guards)
+    end
+  end
+end

data/spec/blather/stream/client_spec.rb

@@ -11,7 +11,7 @@ describe 'Blather::Stream::Client' do
 
   def mocked_server(times = nil, &block)
     @client ||= mock()
-    @client.stubs(:stopped) unless @client.respond_to?(:stopped)
+    @client.stubs(:unbind) unless @client.respond_to?(:unbind)
     @client.stubs(:jid=) unless @client.respond_to?(:jid=)
 
     MockServer.any_instance.expects(:receive_data).send(*(times ? [:times, times] : [:at_least, 1])).with &block
@@ -58,7 +58,7 @@ describe 'Blather::Stream::Client' do
 
   it 'sends stanzas to the client when the stream is ready' do
     @client = mock()
-    @client.expects(:call).with do |n|
+    @client.expects(:receive_data).with do |n|
       EM.stop
       n.kind_of?(Stanza::Message) && @stream.ready?.must_equal(true)
     end
@@ -72,7 +72,7 @@ describe 'Blather::Stream::Client' do
 
   it 'puts itself in the stopped state and calls @client.stopped when stopped' do
     @client = mock()
-    @client.expects(:stopped).at_least_once
+    @client.expects(:unbind).at_least_once
 
     started = false
     mocked_server(2) do |val, server|
@@ -95,8 +95,8 @@ describe 'Blather::Stream::Client' do
   it 'will be in the negotiating state during feature negotiations' do
     state = nil
     @client = mock()
-    @client.stubs(:stream_started)
-    @client.expects(:call).with do |n|
+    @client.stubs(:post_init)
+    @client.expects(:receive_data).with do |n|
       EM.stop
       state.must_equal(:negotiated) && @stream.negotiating?.must_equal(false)
     end
@@ -154,7 +154,7 @@ describe 'Blather::Stream::Client' do
 
   it 'sends client an error on stream:error' do
     @client = mock()
-    @client.expects(:call).with do |v|
+    @client.expects(:receive_data).with do |v|
       v.name.must_equal :conflict
       v.text.must_equal 'Already signed in'
       v.to_s.must_equal "Stream Error (conflict): #{v.text}"
@@ -216,7 +216,7 @@ describe 'Blather::Stream::Client' do
   it 'will fail if TLS negotiation fails' do
     state = nil
     @client = mock()
-    @client.expects(:call).with { |v| v.must_be_kind_of TLSFailure }
+    @client.expects(:receive_data).with { |v| v.must_be_kind_of TLSFailure }
     mocked_server(3) do |val, server|
       case state
       when nil
@@ -245,7 +245,7 @@ describe 'Blather::Stream::Client' do
   it 'will fail if a bad node comes through TLS negotiations' do
     state = nil
     @client = mock()
-    @client.expects(:call).with do |v|
+    @client.expects(:receive_data).with do |v|
       v.must_be_kind_of UnknownResponse
       v.node.element_name.must_equal 'foo-bar'
     end
@@ -400,7 +400,7 @@ describe 'Blather::Stream::Client' do
   it 'tries each possible mechanism until it fails completely' do
     state = nil
     @client = mock()
-    @client.expects(:call).with do |n|
+    @client.expects(:receive_data).with do |n|
       n.must_be_kind_of(SASLError)
       n.name.must_equal :not_authorized
     end
@@ -473,7 +473,7 @@ describe 'Blather::Stream::Client' do
 
   it 'sends client an error when an unknown mechanism is sent' do
     @client = mock()
-    @client.expects(:call).with { |v| v.must_be_kind_of(Stream::SASL::UnknownMechanism) }
+    @client.expects(:receive_data).with { |v| v.must_be_kind_of(Stream::SASL::UnknownMechanism) }
     started = false
     mocked_server(2) do |val, server|
       if !started
@@ -500,7 +500,7 @@ describe 'Blather::Stream::Client' do
   ].each do |error_type|
     it "fails on #{error_type}" do
       @client = mock()
-      @client.expects(:call).with do |n|
+      @client.expects(:receive_data).with do |n|
         n.name.must_equal error_type.gsub('-','_').to_sym
       end
       state = nil
@@ -532,7 +532,7 @@ describe 'Blather::Stream::Client' do
 
   it 'fails when an unkown node comes through during SASL negotiation' do
     @client = mock()
-    @client.expects(:call).with do |n|
+    @client.expects(:receive_data).with do |n|
       n.must_be_instance_of UnknownResponse
       n.node.element_name.must_equal 'foo-bar'
     end
@@ -629,7 +629,7 @@ describe 'Blather::Stream::Client' do
   it 'will return an error if resource binding errors out' do
     state = nil
     @client = mock()
-    @client.expects(:call).with do |n|
+    @client.expects(:receive_data).with do |n|
       n.name.must_equal :bad_request
     end
     mocked_server(3) do |val, server|
@@ -660,7 +660,7 @@ describe 'Blather::Stream::Client' do
   it 'will return an error if an unkown node comes through during resouce binding' do
     state = nil
     @client = mock()
-    @client.expects(:call).with do |n|
+    @client.expects(:receive_data).with do |n|
       n.must_be_instance_of UnknownResponse
       n.node.element_name.must_equal 'foo-bar'
     end
@@ -692,7 +692,7 @@ describe 'Blather::Stream::Client' do
   it 'will establish a session if requested' do
     state = nil
     @client = mock()
-    @client.expects(:stream_started)
+    @client.expects(:post_init)
 
     mocked_server(3) do |val, server|
       case state
@@ -723,7 +723,7 @@ describe 'Blather::Stream::Client' do
   it 'will return an error if session establishment errors out' do
     state = nil
     @client = mock()
-    @client.expects(:call).with do |n|
+    @client.expects(:receive_data).with do |n|
       n.name.must_equal :internal_server_error
     end
     mocked_server(3) do |val, server|
@@ -754,7 +754,7 @@ describe 'Blather::Stream::Client' do
   it 'will return an error if an unknown node come through during session establishment' do
     state = nil
     @client = mock()
-    @client.expects(:call).with do |n|
+    @client.expects(:receive_data).with do |n|
       n.must_be_instance_of UnknownResponse
       n.node.element_name.must_equal 'foo-bar'
     end
@@ -785,7 +785,7 @@ describe 'Blather::Stream::Client' do
 
   it 'sends client an error on parse error' do
     @client = mock()
-    @client.expects(:call).with do |v|
+    @client.expects(:receive_data).with do |v|
       v.must_be_kind_of ParseError
       v.message.must_match(/generate\-parse\-error/)
     end

data/spec/blather/stream/component_spec.rb

@@ -11,7 +11,7 @@ describe 'Blather::Stream::Component' do
 
   def mocked_server(times = nil, &block)
     @client ||= mock()
-    @client.stubs(:stopped) unless @client.respond_to?(:stopped)
+    @client.stubs(:unbind) unless @client.respond_to?(:unbind)
     @client.stubs(:jid=) unless @client.respond_to?(:jid=)
 
     MockServer.any_instance.expects(:receive_data).send(*(times ? [:times, times] : [:at_least, 1])).with &block
@@ -60,8 +60,8 @@ describe 'Blather::Stream::Component' do
   end
 
   it 'sends stanzas to the client when the stream is ready' do
-    @client = mock(:stream_started)
-    @client.expects(:call).with do |n|
+    @client = mock(:post_init)
+    @client.expects(:receive_data).with do |n|
       EM.stop
       n.kind_of?(Stanza::Message) && @stream.ready?.must_equal(true)
     end

data/spec/spec_helper.rb

@@ -1,4 +1,7 @@
-require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. lib blather]))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), *%w[.. lib]))
+
+require 'blather'
 require 'rubygems'
 require 'minitest/spec'
 require 'mocha'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sprsquish-blather
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Jeff Smick
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-12 00:00:00 -07:00
+date: 2009-05-14 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,7 +30,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.3
+        version: 1.1.2
     version: 
 description: 
 email: sprsquish@gmail.com
@@ -44,6 +44,7 @@ extra_rdoc_files:
 files: 
 - examples/drb_client.rb
 - examples/echo.rb
+- examples/ping_pong.rb
 - examples/print_heirarchy.rb
 - ext/extconf.rb
 - ext/push_parser.c
@@ -110,6 +111,8 @@ signing_key:
 specification_version: 3
 summary: An evented XMPP library written on EventMachine and libxml-ruby
 test_files: 
+- spec/blather/client/client_spec.rb
+- spec/blather/client/dsl_spec.rb
 - spec/blather/core_ext/libxml_spec.rb
 - spec/blather/errors/sasl_error_spec.rb
 - spec/blather/errors/stanza_error_spec.rb