em-xmpp 0.0.1 → 0.0.2

data/README.md

@@ -1,9 +1,18 @@
 # Em::Xmpp
 
-TODO: Write a gem description
+EM::Xmpp is an XMPP client library for EventMachine.
+It uses Nokogiri as an XML parser and XML builder.
+
+EM::Xmpp provides decorator-style modules in the mean of contexts
+to easily match and reply to stanzas.
 
 ## Installation
 
+### Standard
+
+    gem install em-xmpp
+
+### Bundler
 Add this line to your application's Gemfile:
 
     gem 'em-xmpp'
@@ -18,7 +27,92 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Connecting to an XMPP server
+
+Like many EventMachine libraries, you need to first create a module and pass it
+to EM::Xmpp::Connection.start
+
+When the connection is ready, EM::Xmpp will call :ready on your connection
+object.  From that point, you can start handling stanzas.
+
+### Receiving stanzas
+
+You can setup handlers for message, presence, and iq with on_message,
+on_presence, and on_iq methods.  All these methods take a callback block
+argument. EM::Xmpp will be call-back the block with a Context object. This
+context object helps you while reading the content of a stanza and replying to
+it.
+
+You may have multiple handlers per stanza type and the callback block argument
+must return the same or another context that will be used for further matching.
+This layering lets you write stack-like middlewares where every Context handler
+adds some features/environment-variables to the Context.
+
+You can call #done! on a Context to notify the stack that you are done with
+this stanza. That is, you do not give a chance to subsequent handlers to match
+on the stanza.
+
+You can also call #delete_xpath_handler! on a context handler to remove it from
+the stack for the next stanzas. This let you build temporary handlers quite
+easily.
+
+Any handler can also throw :halt to interrupt the layering and all the handler
+removal operations. You should read the code to understand well what you skip
+by doing so.
+
+You can use on(*xpath_args) to build a matcher for any XPath in the stanza.
+The arguments are passed verbatim to Nokogiri. A special argument is
+on(:anything) that will match any stanza (e.g., for logging).  This is useful
+to build new decorators for handling a specific XEP (if you do so, please share
+with a pull-request).
+
+When an exception occurs in a stanza handler, the stack rescues the error and
+runs the Context through a set of exception handlers. To handle exception you
+can use the on_exception(:anything) method.
+
+See the ./samples directory for basic examples.
+
+### Sending stanzas
+
+EM::XMPP for now builds stanzas with Nokogiri::XML::Builder in the form with an
+explicit block argument.
+Then you send raw_strings with Connection#send_raw or pre-built stanzas with Connection#send_stanza.
+Note that if you send malformed XML, your server will disconnect you. Hence,
+take care when writing XML without and XML builder.
+
+Contexts for message/iq/presence provide a "reply" method that will pre-fill
+some fields for you. Otherwise, you can use 
+
+    data = message_stanza('to' => 'someone@somehost') do |xml| 
+             xml.body('hello world')
+           end
+    send_stanza data
+
+to send a stanza to someone. Note that since EM:Xmpp sets jabber:client as
+default namespace of the XML stream, you must not set the XML namespace for
+body/iq/presence and all the things that sit in jabber:client namespace. For
+other XEPs, do not forget to set your namespaces.
+
+The XML::Builder uses method_missing and hence this building scheme may be slow
+if you need a large throughput of outgoing stanzas.
+
+See the ./samples directory for basic examples.
+
+## Features and Missing
+
+This library does not manage the roster for you. You will have to
+do this by hand.
+
+We do not support but plan to support anonymous login yet.
+
+We do not support but may support component login in the future.
+
+SASL authentication uses the ruby-sasl gem. It misses some types of
+authentication (for example, X-GOOGLE-TOKEN). 
+
+This library lets you manage the handling and matching of stanza quite close to
+the wire. .
+
 
 ## Contributing
 

data/lib/em-xmpp/connection.rb

@@ -48,7 +48,7 @@ module EM::Xmpp
     def negotiation_finished
       @pass    = nil
       @handler = Routine.new self
-      send_raw presence_stanza()
+      send_stanza presence_stanza()
       ready
     end
 
@@ -56,44 +56,61 @@ module EM::Xmpp
       raise RuntimeError, "could not negotiate a stream:\n#{node}"
     end
 
-    #should add 'xml:lang'
+    OutgoingStanza = Struct.new(:xml, :params)
 
-    def default_presence_config
+    def default_presence_params
       {}
     end
 
-    def default_message_config
+    def default_message_params
       {'to' => @jid.domain, 'id' => "em-xmpp.#{rand(65535)}"}
     end
 
-    def default_iq_config
+    def default_iq_params
       {'type' => 'get', 'id' => "em-xmpp.#{rand(65535)}"}
     end
 
-    def presence_stanza(cfg={}, &blk)
-      cfg = default_presence_config.merge(cfg)
-      build_xml do |x|
-        x.presence(cfg, &blk)
+    def presence_stanza(params={}, &blk)
+      params = default_presence_params.merge(params)
+      xml = build_xml do |x|
+        x.presence(params, &blk)
       end
+      OutgoingStanza.new xml, params
     end
 
-    def message_stanza(cfg={}, &blk)
-      cfg = default_message_config.merge(cfg)
-      build_xml do |x|
-        x.message(cfg, &blk)
+    def message_stanza(params={}, &blk)
+      params = default_message_params.merge(params)
+      xml = build_xml do |x|
+        x.message(params, &blk)
       end
+      OutgoingStanza.new xml, params
     end
 
-    def iq_stanza(cfg={}, &blk)
-      cfg = default_iq_config.merge(cfg)
-      build_xml do |x|
-        x.iq(cfg, &blk)
+    def iq_stanza(params={}, &blk)
+      params = default_iq_params.merge(params)
+      xml = build_xml do |x|
+        x.iq(params, &blk)
+      end
+      OutgoingStanza.new xml, params
+    end
+
+    def send_stanza(stanza)
+      send_raw stanza.xml
+      if block_given?
+        on(:anything) do |ctx|
+          if ctx.id == stanza.params['id']
+            yield ctx
+            ctx.delete_xpath_handler!
+          else
+            ctx
+          end
+        end
       end
     end
 
     %w{on on_exception on_presence on_iq on_message}.each do |meth|
       define_method(meth) do |*args,&blk|
-      @handler.send meth, *args, &blk
+        @handler.send meth, *args, &blk
       end
     end
 

data/lib/em-xmpp/context.rb

@@ -2,6 +2,7 @@
 require 'em-xmpp/jid'
 require 'em-xmpp/namespaces'
 require 'time'
+require 'ostruct'
 
 module EM::Xmpp
   class Context
@@ -74,7 +75,7 @@ module EM::Xmpp
       obj
     end
 
-    module Stanza
+    module IncomingStanza
       include Namespaces
       %w{type id lang}.each do |w|
         define_method w do
@@ -87,10 +88,42 @@ module EM::Xmpp
       def from
         read_attr(stanza, 'from'){|j| JID.parse(j)}
       end
+      def error?
+        type == 'error'
+      end
+      def delay?
+        false
+      end
+    end
+
+    module Error
+      def error_node
+        xpath('//xmlns:error',{'xmlns' => Client}).first
+      end
+
+      def error_code
+        n = error_node
+        read_attr(n, 'code') if n
+      end
+
+      def error_type
+        n = error_node
+        read_attr(n, 'type') if n
+      end
+
+      def error_condition_node
+        n = error_node
+        n.children.first if n
+      end
+
+      def error_condition
+        n = error_condition_node
+        n.name if n
+      end
     end
 
     module Presence
-      include Stanza
+      include IncomingStanza
       def reply_default_params
         jid = @connection.jid.full
         {'from' => jid, 'to' => from, 'id' => id}
@@ -123,10 +156,13 @@ module EM::Xmpp
       def subscription_request?
         type == 'subscribe'
       end
+      def entity_left?
+        type == 'unavailable'
+      end
     end
 
     module Message
-      include Stanza
+      include IncomingStanza
       def subject_node
         xpath('//xmlns:subject',{'xmlns' => Client}).first
       end
@@ -155,10 +191,14 @@ module EM::Xmpp
         args = reply_default_params.merge args
         @connection.message_stanza(args,&blk)
       end
+
+      def groupchat?
+        type == 'groupchat'
+      end
     end
 
     module Iq
-      include Stanza
+      include IncomingStanza
       def reply_default_params
         jid = @connection.jid.full
         {'from' => jid, 'to' => from, 'type' => 'result', 'id' => id}
@@ -171,6 +211,9 @@ module EM::Xmpp
     end
 
     module Delay
+      def delay?
+        true
+      end
       #does not handle legacy delay
       def delay_node
         xpath('//xmlns:delay',{'xmlns' => EM::Xmpp::Namespaces::Delay}).first
@@ -245,5 +288,228 @@ module EM::Xmpp
         end
       end
     end
+
+    module Roster
+      def query_node
+        xpath('//xmlns:query',{'xmlns' => EM::Xmpp::Namespaces::Roster}).first
+      end
+
+      def items
+        n = query_node
+        if n
+          n.children.map do |xml|
+            new_subscription(xml)
+          end
+        end
+      end
+
+      private
+
+      Subscription = Struct.new(:type, :jid, :name, :groups)
+
+      def new_subscription(n)
+        type = read_attr(n,'subscription')
+        jid  = read_attr(n,'jid') {|x| JID.parse x}
+        name = read_attr(n,'name')
+        groups = n.xpath('xmlns:group', 'xmlns' => EM::Xmpp::Namespaces::Roster).map{|n| n.content}
+        Subscription.new(type, jid, name, groups)
+      end
+    end
+
+    module Tune
+      def tune_node
+        xpath('//xmlns:tune',{'xmlns' => Namespaces::Tune}).first
+      end
+
+      DecimalFields = %w{length rating}.freeze
+      StringFields = %w{artist source title track uri}.freeze
+
+      DecimalFields.each do |decimal|
+        define_method(decimal) do 
+          n = tune_node
+          if n
+            d = n.children.find{|c| c.name == decimal}
+            d.content.to_i if d
+          end
+        end
+      end
+
+
+      StringFields.each do |str|
+        define_method(str) do 
+          n = tune_node
+          if n
+            d = n.children.find{|c| c.name == str}
+            d.content
+          end
+        end
+      end
+
+      def tune
+        ostruct = OpenStruct.new
+        (StringFields + DecimalFields).each do |field|
+          val = send field
+          ostruct.send("#{field}=", val)
+        end
+        ostruct
+      end
+    end
+
+    module Nickname
+      def nickname_node
+        xpath('//xmlns:nick',{'xmlns' => Nick}).first
+      end
+      def nickname
+        n = nickname_node
+        n.content if n
+      end
+    end
+
+    module Geolocation
+      def geoloc_node
+        xpath('//xmlns:nick',{'xmlns' => Geoloc}).first
+      end
+
+      def geoloc
+        ostruct = OpenStruct.newt
+        (StringFields + DecimalFields + %w{timestamp}).each do |field|
+          val = send field
+          ostruct.send("#{field}=", val)
+        end
+        ostruct
+      end
+
+      StringFields = %w{area building country countrycode datum description
+        floor locality postalcode region room street text uri}.freeze
+      DecimalFields = %w{accuracy error alt lat lon bearing speed}.freeze
+
+      DecimalFields.each do |decimal|
+        define_method(decimal) do 
+          n = geoloc_node
+          if n
+            d = n.children.find{|c| c.name == decimal}
+            d.content.to_i if d
+          end
+        end
+      end
+
+      StringFields.each do |str|
+        define_method(str) do 
+          n = geoloc_node
+          if n
+            d = n.children.find{|c| c.name == str}
+            d.content
+          end
+        end
+      end
+
+      def timestamp
+        n = geoloc_node
+        if n
+          d = n.children.find{|c| c.name == 'timestamp'}
+          Time.parse d.content if d
+        end
+      end
+    end
+
+    module Useractivity
+      def activity_node
+        xpath('//xmlns:mood',{'xmlns' => Namespaces::Activity}).first
+      end
+
+      def activity_category_node
+        n = activity_node
+        n.children.first if n
+      end
+
+      def activity_text_node
+        n = activity_node
+        n.children.find{|n| n.name == 'text'} if n
+      end
+
+      def activity
+        ret = []
+        n = activity_category_node
+        if n
+          ret << n.name 
+          detail = n.children.first
+          ret << detail.name if detail
+        end
+        ret
+      end
+
+      def activity_text
+        n = activity_text_node
+        n.content if n
+      end
+    end
+
+    module Mood
+      DefinedMoods = %w{afraid amazed angry amorous annoyed anxious aroused
+ashamed bored brave calm cautious cold confident confused contemplative
+contented cranky crazy creative curious dejected depressed disappointed
+disgusted dismayed distracted embarrassed envious excited flirtatious
+frustrated grumpy guilty happy hopeful hot humbled humiliated hungry hurt
+impressed in_awe in_love indignant interested intoxicated invincible jealous
+lonely lucky mean moody nervous neutral offended outraged playful proud relaxed
+relieved remorseful restless sad sarcastic serious shocked shy sick sleepy
+spontaneous stressed strong surprised thankful thirsty tired undefined weak
+worried}.freeze
+
+      def mood_node
+        xpath('//xmlns:mood',{'xmlns' => Namespaces::Mood}).first
+      end
+      def mood_name_node
+        n = mood_node
+        n.children.find{|c| DefinedMoods.include?(c.name)} if n
+      end
+      def mood_text_node
+        n = mood_node
+        n.children.find{|c| c.name == 'text'}
+      end
+      def mood
+        n = mood_name_node
+        n.name if n
+      end
+      def mood
+        n = mood_text_node
+        n.content if n
+      end
+    end
+
+    module Mucuser
+      def x_node
+        xpath('//xmlns:x',{'xmlns' => EM::Xmpp::Namespaces::MucUser}).first
+      end
+
+      def item_node
+        xpath('//xmlns:item',{'xmlns' => EM::Xmpp::Namespaces::MucUser}).first
+      end
+
+      def status_node
+        xpath('//xmlns:status',{'xmlns' => EM::Xmpp::Namespaces::MucUser}).first
+      end
+
+      def status
+        n = status_node
+        read_attr(n, 'code') if n
+      end
+
+      def jid
+        n = item_node
+        jid_str = read_attr(n, 'jid') if n
+        JID.parse jid_str if jid_str
+      end
+
+      def affiliation
+        n = item_node
+        read_attr(n, 'affiliation') if n
+      end
+
+      def role
+        n = item_node
+        read_attr(n, 'role') if n
+      end
+    end
   end
 end

data/lib/em-xmpp/handler.rb

@@ -1,6 +1,8 @@
 
 require 'em-xmpp/namespaces'
 require 'em-xmpp/context'
+require 'em-xmpp/stanza_matcher'
+require 'em-xmpp/stanza_handler'
 require 'base64'
 require 'sasl/base'
 require 'sasl'
@@ -9,16 +11,10 @@ module EM::Xmpp
   class Handler
     include Namespaces
 
-    Xpath = Struct.new(:path, :args, :blk) do
-      def match?(xml)
-        path == :anything or xml.xpath(path, args).any?
-      end
-    end
-
     def initialize(conn)
       @connection         = conn
-      @xpaths             = []
-      @exception_xpaths   = []
+      @handlers           = []
+      @exception_handlers = []
 
       stack_decorators
     end
@@ -36,9 +32,21 @@ module EM::Xmpp
     end
 
     def stack_decorators
-      on_presence { |ctx| ctx.with(:presence) }
-      on_message  { |ctx| ctx.with(:message) }
-      on_iq       { |ctx| ctx.with(:iq) }
+      on_presence do |ctx| 
+        ctx = ctx.with(:presence) 
+        ctx = ctx.with(:error) if ctx.error?
+        ctx
+      end
+      on_message  do |ctx| 
+        ctx = ctx.with(:message) 
+        ctx = ctx.with(:error) if ctx.error?
+        ctx
+      end
+      on_iq       do |ctx| 
+        ctx = ctx.with(:iq) 
+        ctx = ctx.with(:error) if ctx.error?
+        ctx
+      end
       on('//xmlns:delay', 'xmlns' => Delay) do |ctx|
         ctx.with(:delay)
       end
@@ -48,20 +56,51 @@ module EM::Xmpp
       on('//xmlns:query', 'xmlns' => DiscoverItems) do |ctx|
         ctx.with(:discoitems)
       end
+      on('//xmlns:query', 'xmlns' => Roster) do |ctx|
+        ctx.with(:roster)
+      end
       on('//xmlns:command', 'xmlns' => Commands) do |ctx|
         ctx.with(:command)
       end
       on('//xmlns:x', 'xmlns' => DataForms) do |ctx|
         ctx.with(:dataforms)
       end
+      on('//xmlns:nick', 'xmlns' => Nick) do |ctx|
+        ctx.with(:nickname)
+      end
+      on('//xmlns:x', 'xmlns' => MucUser) do |ctx|
+        ctx.with(:mucuser)
+      end
+    end
+
+    def add_handler(handler)
+      @handlers << handler
+    end
+
+    def add_exception_handler(handler)
+      @exception_handlers << handler
+    end
+
+    def remove_handler(handler)
+      @handlers.delete handler
+    end
+
+    def remove_exception_handler(handler)
+      @exception_handlers.delete handler
     end
 
     def on(path, args={}, &blk)
-      @xpaths << Xpath.new(path, args, blk)
+      matcher = StanzaMatcher.new(path, args)
+      handler = StanzaHandler.new(matcher, blk)
+      add_handler handler
+      handler
     end
 
     def on_exception(path, args={}, &blk)
-      @exception_xpaths << Xpath.new(path, args, blk)
+      matcher = StanzaMatcher.new(path, args)
+      handler = StanzaHandler.new(matcher, &blk)
+      add_exception_handler handler
+      handler
     end
 
     # wraps the stanza in a context and calls handle_context
@@ -69,9 +108,9 @@ module EM::Xmpp
       handle_context Context.new(@connection, stanza)
     end
 
-    # runs all xpath_handlers against the stanza context
+    # runs all handlers against the stanza context
     # catches all exception (in which case, the context gets passed to all
-    # exception_xpaths)
+    # exception_handlers)
     #
     # an xpath handler can:
     # - throw :halt to shortcircuit everything
@@ -80,25 +119,17 @@ module EM::Xmpp
     # handlers such as request/responses
     def handle_context(ctx)
       catch :halt do
-        @xpaths = run_xpath_handlers ctx, @xpaths
+        @handlers = run_xpath_handlers ctx, @handlers.dup
       end
     rescue => err
       ctx['error'] = err
-      @exception_xpaths = run_xpath_handlers ctx, @exception_xpaths
+      @exception_handlers = run_xpath_handlers ctx, @exception_handlers
     end
 
     # runs all handlers and returns a list of handlers for the next stanza
     def run_xpath_handlers(ctx, handlers)
       handlers.map do |x|
-        if (not ctx.done?) and (x.match?(ctx.stanza))
-          ctx['xpath.handler'] = x
-          ctx = x.blk.call(ctx)
-          raise RuntimeError, "xpath handlers should return a Context" unless ctx.is_a?(Context)
-
-          x if ctx.reuse_handler?
-        else
-          x
-        end
+        x.call ctx
       end.compact
     end
   end
@@ -150,6 +181,9 @@ module EM::Xmpp
     end
 
     def setup_handlers
+      on_exception(:anything) do |ctx|
+        raise ctx['error']
+      end
       on('//xmlns:starttls', {'xmlns' => TLS}) do |ctx|
         @connection.ask_for_tls 
         ctx.delete_xpath_handler!.done!
@@ -220,7 +254,7 @@ module EM::Xmpp
     end
 
     def bind_to_resource(wanted_res=nil)
-      c.send_raw(c.iq_stanza('type' => 'set') do |x|
+      c.send_stanza(c.iq_stanza('type' => 'set') do |x|
         x.bind('xmlns' => Bind) do |y|
           y.resource(wanted_res) if wanted_res
         end
@@ -228,7 +262,7 @@ module EM::Xmpp
     end
 
     def start_session
-      c.send_raw(c.iq_stanza('type' => 'set', 'to' => jid.domain) do |x|
+      c.send_stanza(c.iq_stanza('type' => 'set', 'to' => jid.domain) do |x|
         x.session('xmlns' => Session) 
       end)
     end

data/lib/em-xmpp/namespaces.rb

@@ -21,11 +21,29 @@ module EM::Xmpp
     DiscoverItems = "http://jabber.org/protocol/disco#items"
     #XMPP info discovery
     DiscoverInfos = "http://jabber.org/protocol/disco#infos"
+    #Jabber Roster
+    Roster = 'jabber:iq:roster'
     #XMPP commands
     Commands = "http://jabber.org/protocol/commands"
+    #entity nicknames
+    Nick = "http://jabber.org/protocol/nick"
+    #entity activity
+    Activity = "http://jabber.org/protocol/activity"
+    #entity mood
+    Mood = "http://jabber.org/protocol/mood"
+    #entity geoloc
+    Geoloc = "http://jabber.org/protocol/geoloc"
+    #entity's song
+    Tune = "http://jabber.org/protocol/tune"
     #XMPP delayed delivery
     Delay = "urn:xmpp:delay"
     #Jabber Data forms
     DataForms  = 'jabber:x:data'
+    #Multi user chat - simple user
+    MucUser = 'http://jabber.org/protocol/muc#user'
+    #Multi user chat - owner
+    MucOwner = 'http://jabber.org/protocol/muc#owner'
+    #Multi user chat - roomconfig
+    MucRoomconfig = 'http://jabber.org/protocol/muc#roomconfig'
   end
 end

data/lib/em-xmpp/stanza_handler.rb

@@ -0,0 +1,28 @@
+
+module EM::Xmpp
+  class StanzaHandler
+    attr_reader :matcher, :callback 
+    def initialize(matcher, cb=nil, &blk)
+      raise ArgumentError unless matcher.respond_to? :match?
+      @matcher  = matcher
+      @callback = cb || blk
+    end
+
+    def match?(obj)
+      matcher.match? obj
+    end
+
+    def call(ctx)
+      if (not ctx.done?) and (match?(ctx.stanza))
+        ctx['xpath.handler'] = self
+        ctx = callback.call(ctx)
+        raise RuntimeError, "xpath handlers should return a Context" unless ctx.is_a?(Context)
+
+        self if ctx.reuse_handler?
+      else
+        self
+      end
+    end
+  end
+end
+

data/lib/em-xmpp/stanza_matcher.rb

@@ -0,0 +1,22 @@
+
+module EM::Xmpp
+  class StanzaMatcher
+    attr_reader :matcher
+
+    def initialize(obj=nil,args={},&blk)
+      obj ||= blk
+      @matcher = case obj
+                 when :anything
+                   proc { true }
+                 when String
+                   proc { |xml| xml.xpath(obj, args).any? }
+                 else
+                   obj
+                 end
+    end
+
+    def match?(xml)
+      matcher.call xml
+    end
+  end
+end

data/lib/em-xmpp/version.rb

@@ -1,5 +1,5 @@
 module Em
   module Xmpp
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/samples/echo.rb

@@ -19,15 +19,47 @@ module MyClient
   def ready
     puts "***** #{@jid} ready for #{self}"
 
+    # Sending a stanza and adding a temporary matcher to it.
+    # Returns an handler object that is already ready to process further stanzas.
+    # Note that so far there is no way to time-out such an handler automatically.
+    handler = send_stanza(iq_stanza('to'=> 'dicioccio@mbpldc.local') do |x|
+      x.body "this will trigger an XMPP error"
+    end) do |ctx|
+      if ctx.error?
+        p ctx.error_code
+        p ctx.error_type
+        p ctx.error_condition
+      end
+      ctx
+    end
+
+    # Exception handling (i.e., when Ruby raises something)
+    on_exception(:anything) do |ctx|
+      raise ctx['error']
+    end
+
+    # Manually add a matcher + handler for it
+    m = EM::Xmpp::StanzaMatcher.new do |ctx|
+      p "proc-ing"
+      true
+    end
+    h = EM::Xmpp::StanzaHandler.new(m) do |ctx|
+      p "proc-ed"
+      ctx
+    end
+    @handler.add_handler h
+
+    # Presence handler
     on_presence do |s|
       p "*presence> #{s.from} #{s.show} (#{s.status})"
-      send_raw(s.reply('type'=>'subscribed')) if s.subscription_request?
+      send_stanza(s.reply('type'=>'subscribed')) if s.subscription_request?
       s
     end
 
+    # Message handler
     on_message do |s|
       p "*message> #{s.from}\n#{s.body}\n"
-      send_raw(s.reply do |x|
+      send_stanza(s.reply do |x|
         x.body "you sent:#{s.body}"
       end)
       s

data/samples/muc.rb

@@ -0,0 +1,95 @@
+
+$LOAD_PATH.unshift './lib'
+require 'em-xmpp'
+require 'em-xmpp/namespaces'
+require 'em-xmpp/nodes'
+
+if ARGV.size < 3
+  puts "usage: #{__FILE__} <jid> <pass> <muc> [<invitees>...]"
+  exit 0 
+end
+
+jid     = ARGV.first
+pass    = ARGV[1]
+muc     = ARGV[2]
+invitees = ARGV[3 .. -1]
+
+include EM::Xmpp::Namespaces
+include EM::Xmpp::Nodes
+
+module MyClient
+  def join_muc(muc, login='myclient')
+    p "joining muc: #{muc}"
+    muc = [muc, login].join('/')
+    send_stanza presence_stanza('to'=> muc, 'id' => 'join.muc')
+  end
+
+  def leave_muc(muc, login='myclient')
+    p "leaving muc: #{muc}"
+    muc = [muc, login].join('/')
+    send_stanza(presence_stanza('to'=> muc, 'id' => 'leave.muc', 'type' => 'unavailable')) do |ctx|
+      p "left muc"
+      ctx
+    end
+  end
+
+  def invite_to_muc(invitee, muc, text)
+    p "inviting #{invitee} to #{muc}"
+    send_stanza(message_stanza('to' => muc, 'type' => 'normal') do |xml|
+      xml.x(:xmlns => 'http://jabber.org/protocol/muc#user') do |x|
+        x.invite(:to => invitee) do |invite|
+          invite.reason do |reason|
+            reason.text text
+          end
+        end
+      end
+    end)
+  end
+
+  attr_accessor :muc
+  attr_accessor :invitees
+
+  def ready
+    puts "***** #{@jid} ready for #{self}"
+
+    join_muc(muc)
+
+    on('//xmlns:x', 'xmlns' => EM::Xmpp::Namespaces::MucUser) do |ctx|
+      muc = ctx.jid.bare if ctx.jid
+      p ctx.jid
+      p ctx.affiliation
+      p ctx.role
+      if ctx.status
+        invitees.each do |invitee|
+          p invitee
+          invite_to_muc muc, invitee, "hello, join my MUC" 
+        end
+      end
+      ctx
+    end
+
+    on_message do |ctx|
+      p "message"
+      p ctx.nickname if ctx.respond_to?(:nickname)
+      leave_muc(muc) if ctx.body =~ /leave/ and not ctx.delay?
+      ctx
+    end
+
+    on_exception(:anything) do |ctx|
+      raise ctx['error']
+    end
+
+    on_presence do |s|
+      p "*presence> #{s.from} #{s.show} (#{s.status})"
+      p "  has left" if s.entity_left?
+      s
+    end
+
+  end
+end
+
+EM.run do
+  conn = EM::Xmpp::Connection.start(jid, pass, MyClient)
+  conn.muc = muc
+  conn.invitees = invitees
+end

data/samples/roster.rb

@@ -0,0 +1,41 @@
+
+
+$LOAD_PATH.unshift './lib'
+require 'em-xmpp'
+require 'em-xmpp/namespaces'
+require 'em-xmpp/nodes'
+
+if ARGV.empty?
+  puts "usage: #{__FILE__} <jid> [<pass>]"
+  exit 0 
+end
+
+jid     = ARGV.first
+pass    = ARGV[1]
+
+include EM::Xmpp::Namespaces
+include EM::Xmpp::Nodes
+
+module MyClient
+  def ask_roster
+    send_stanza(iq_stanza do |x|
+      x.query('xmlns' => Roster)
+    end) do |ctx|
+      p ctx.items
+      ctx
+    end
+  end
+
+  def ready
+    puts "***** #{@jid} ready for #{self}"
+    on_exception(:anything) do |ctx|
+      raise ctx['error']
+    end
+
+    ask_roster
+  end
+end
+
+EM.run do
+  EM::Xmpp::Connection.start(jid, pass, MyClient)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: em-xmpp
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-27 00:00:00.000000000Z
+date: 2012-05-05 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &2153101140 !ruby/object:Gem::Requirement
+  requirement: &2160613180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153101140
+  version_requirements: *2160613180
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &2153100720 !ruby/object:Gem::Requirement
+  requirement: &2160612760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153100720
+  version_requirements: *2160612760
 - !ruby/object:Gem::Dependency
   name: ruby-sasl
-  requirement: &2153100300 !ruby/object:Gem::Requirement
+  requirement: &2160612340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153100300
+  version_requirements: *2160612340
 description: XMPP client for event machine
 email:
 - crapooze@gmail.com
@@ -67,8 +67,12 @@ files:
 - lib/em-xmpp/namespaces.rb
 - lib/em-xmpp/nodes.rb
 - lib/em-xmpp/resolver.rb
+- lib/em-xmpp/stanza_handler.rb
+- lib/em-xmpp/stanza_matcher.rb
 - lib/em-xmpp/version.rb
 - samples/echo.rb
+- samples/muc.rb
+- samples/roster.rb
 homepage: https://github.com/crapooze/em-xmpp
 licenses: []
 post_install_message: