blather 0.2.1 → 0.2.2

data/examples/rosterprint.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+# Prints out each roster entry
+
+require 'blather/client'
+
+when_ready do
+  roster.grouped.each do |group, items|
+    puts "#{'*'*3} #{group || 'Ungrouped'} #{'*'*3}"
+    items.each { |item| puts "- #{item.name} (#{item.jid})" }
+    puts
+  end
+  shutdown
+end

data/examples/xmpp4r/echo.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby
+
+# This bot will reply to every message it receives. To end the game, send 'exit'
+
+require 'xmpp4r/client'
+include Jabber
+
+# settings
+if ARGV.length != 2
+  puts "Run with ./echo_thread.rb user@server/resource password"
+  exit 1
+end
+myJID = JID.new(ARGV[0])
+myPassword = ARGV[1]
+cl = Client.new(myJID)
+cl.connect
+cl.auth(myPassword)
+cl.send(Presence.new)
+puts "Connected ! send messages to #{myJID.strip.to_s}."
+mainthread = Thread.current
+cl.add_message_callback do |m|
+  if m.type != :error
+    m2 = Message.new(m.from, "You sent: #{m.body}")
+    m2.type = m.type
+    cl.send(m2)
+    if m.body == 'exit'
+      m2 = Message.new(m.from, "Exiting ...")
+      m2.type = m.type
+      cl.send(m2)
+      mainthread.wakeup
+    end
+  end
+end
+Thread.stop
+cl.close

data/ext/extconf.rb

@@ -0,0 +1,65 @@
+require 'mkmf'
+
+flags = []
+
+case RUBY_PLATFORM.split('-',2)[1]
+when 'mswin32', 'mingw32', 'bccwin32'
+  unless have_header('windows.h') and
+      have_header('winsock.h') and
+      have_library('kernel32') and
+      have_library('rpcrt4') and
+      have_library('gdi32')
+    exit
+  end
+
+  flags << "-D OS_WIN32"
+  flags << '-D BUILD_FOR_RUBY'
+  flags << "-EHs"
+  flags << "-GR"
+
+  dir_config('xml2')
+  exit unless have_library('xml2') && have_header('libxml/parser.h')
+
+when /solaris/
+  unless have_library('pthread') and
+	have_library('nsl') and
+	have_library('socket')
+	  exit
+  end
+
+  flags << '-D OS_UNIX'
+  flags << '-D OS_SOLARIS8'
+  flags << '-D BUILD_FOR_RUBY'
+
+  dir_config('xml2')
+  exit unless have_library('xml2') && find_header('libxml/parser.h', '/usr/include/libxml2')
+
+  # on Unix we need a g++ link, not gcc.
+  #CONFIG['LDSHARED'] = "$(CXX) -shared"
+
+when /darwin/
+  flags << '-DOS_UNIX'
+  flags << '-DBUILD_FOR_RUBY'
+
+  dir_config('xml2')
+  exit unless have_library('xml2') && find_header('libxml/parser.h', '/usr/include/libxml2')
+  # on Unix we need a g++ link, not gcc.
+  #CONFIG['LDSHARED'] = "$(CXX) " + CONFIG['LDSHARED'].split[1..-1].join(' ')
+
+else
+  unless have_library('pthread')
+	  exit
+  end
+
+  flags << '-DOS_UNIX'
+  flags << '-DBUILD_FOR_RUBY'
+
+  dir_config('xml2')
+  exit unless have_library('xml2') && find_header('libxml/parser.h', '/usr/include/libxml2')
+  # on Unix we need a g++ link, not gcc.
+  #CONFIG['LDSHARED'] = "$(CXX) -shared"
+end
+
+$CFLAGS += ' ' + flags.join(' ')
+
+create_makefile "push_parser"

data/lib/blather.rb

@@ -1,10 +1,12 @@
 $:.unshift File.dirname(__FILE__)
+$:.unshift File.join(File.dirname(__FILE__), '..')
 
 # Require the necessary files
 %w[
   rubygems
-  xml/libxml
   eventmachine
+  ext/push_parser
+  xml/libxml
   digest/md5
   logger
 
@@ -12,22 +14,34 @@ $:.unshift File.dirname(__FILE__)
   blather/core_ext/libxml
 
   blather/errors
+  blather/errors/sasl_error
+  blather/errors/stanza_error
+  blather/errors/stream_error
   blather/jid
   blather/roster
   blather/roster_item
   blather/xmpp_node
 
   blather/stanza
-  blather/stanza/error
   blather/stanza/iq
   blather/stanza/iq/query
   blather/stanza/iq/roster
+  blather/stanza/disco
+  blather/stanza/disco/disco_info
+  blather/stanza/disco/disco_items
   blather/stanza/message
   blather/stanza/presence
   blather/stanza/presence/status
   blather/stanza/presence/subscription
+  blather/stanza/pubsub
+  blather/stanza/pubsub/affiliations
+  blather/stanza/pubsub/subscriptions
+  blather/stanza/pubsub/items
 
   blather/stream
+  blather/stream/client
+  blather/stream/component
+  blather/stream/stream_handler
   blather/stream/parser
   blather/stream/resource
   blather/stream/sasl
@@ -38,123 +52,6 @@ $:.unshift File.dirname(__FILE__)
 XML.indent_tree_output = false
 
 module Blather
-  LOG = Logger.new(STDOUT)
-  Stream::Parser.debug = true
-#  LOG.level = Logger::INFO
-
-  class Client
-    attr_accessor :jid,
-                  :roster
-
-    def initialize
-      @state = :initializing
-
-      @status = Stanza::Presence::Status.new
-      @handlers = Hash.new { |h,k| h[k] = [] }
-      @roster = Roster.new self
-
-      setup_initial_handlers
-    end
-
-    def register_handler(type, &handler)
-      @handlers[type] << 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(data)
-      @stream.send(data) if @stream
-    end
-
-    def stream_started(stream)
-      @stream = stream
-
-      #retreive roster
-      write Stanza::Iq::Roster.new
-    end
-
-    def call(stanza)
-      stanza.handler_heirarchy.each do |type|
-        break if call_handler_for(type, stanza) && stanza.type == :iq
-      end
-    end
-
-    def call_handler_for(type, stanza)
-      if @handlers[type]
-        @handlers[type].each { |handler| handler.call(stanza) }
-        true
-      end
-    end
-
-  protected
-    def setup_initial_handlers
-      register_handler :iq do |iq|
-        write(Stanza::Error.new_from(iq, 'service-unavailable', 'cancel').reply!) if [:set, :get].include?(iq.type)
-      end
-
-      register_handler :status do |status|
-        roster[status.from].status = status if roster[status.from]
-      end
-
-      register_handler :roster do |node|
-        roster.process node
-        if @state == :initializing
-          @state = :ready
-          write @status
-          call_handler_for :ready, nil
-        end
-      end
-    end
-
-  end #Client
-
-  module Application
-    @@client = Blather::Client.new
-
-    def setup(jid, password, host = nil, port = 5222)
-      at_exit do
-        trap(:INT) { EM.stop }
-        EM.run { Blather::Stream.start @@client, Blather::JID.new(jid), password, host, port }
-      end
-    end
-
-    def daemonize
-      @daemonize = true
-    end
-
-    def handle(stanza_type, &block)
-      @@client.register_handler stanza_type, &block
-    end
-
-    def status(state = nil, msg = nil)
-      @@client.status = state, msg
-    end
-
-    def roster
-      @@client.roster
-    end
-
-    def write(stanza)
-      @@client.write(stanza)
-    end
-
-    def say(to, msg)
-      @@client.write Blather::Stanza::Message.new(to, msg)
-    end
-  end #Application
-
+  LOG = Logger.new(STDOUT) unless const_defined?(:LOG)
+  LOG.level = Logger::INFO
 end
-
-include Blather::Application

data/lib/blather/client.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), *%w[client dsl])
+
+include Blather::DSL
+
+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
+    end
+  end
+end

data/lib/blather/client/client.rb

@@ -0,0 +1,165 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. blather])
+require File.join(File.dirname(__FILE__), 'pubsub')
+
+module Blather #:nodoc:
+
+  class Client #:nodoc:
+    attr_accessor :jid,
+                  :roster
+
+    def initialize
+      @state = :initializing
+
+      @status = Stanza::Presence::Status.new
+      @handlers = {}
+      @tmp_handlers = {}
+      @roster = Roster.new self
+
+      setup_initial_handlers
+    end
+
+    def setup?
+      @setup.is_a? Array
+    end
+
+    def setup(jid, password, host = nil, port = nil)
+      @setup = [JID.new(jid), password]
+      @setup << host if host
+      @setup << port if port
+      self
+    end
+
+    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
+      }
+    end
+
+    def register_tmp_handler(id, &handler)
+      @tmp_handlers[id] = handler
+    end
+
+    def register_handler(type, *guards, &handler)
+      @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)
+      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
+      end
+    end
+
+    def stop
+      @stream.close_connection_after_writing
+    end
+
+    def stopped
+      EM.stop
+    end
+
+    def call(stanza)
+      if handler = @tmp_handlers.delete(stanza.id)
+        handler.call stanza
+      else
+        stanza.handler_heirarchy.each do |type|
+          break if call_handler_for(type, stanza) && (stanza.is_a?(BlatherError) || stanza.type == :iq)
+        end
+      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::ServiceUnavailable.new(iq, :cancel).to_node) if [:set, :get].include?(iq.type)
+      end
+
+      register_handler :status do |status|
+        roster[status.from].status = status if roster[status.from]
+      end
+
+      register_handler :roster do |node|
+        roster.process node
+      end
+    end
+
+    ##
+    # If any of the guards returns FALSE this returns true
+    def guarded?(guards, stanza)
+      guards.find do |guard|
+        case guard
+        when Symbol
+          !stanza.__send__(guard)
+        when Array
+          # return FALSE if any item is TRUE
+          !guard.detect { |condition| !guarded?([condition], stanza) }
+        when Hash
+          # return FALSE unless any inequality is found
+          guard.find do |method, value|
+            if value.is_a?(Regexp)
+              !stanza.__send__(method).to_s.match(value)
+            else
+              stanza.__send__(method) != value
+            end
+          end
+        when Proc
+          !guard.call(stanza)
+        else
+          raise "Bad guard: #{guard.inspect}"
+        end
+      end
+    end
+
+  end #Client
+end #Blather