em-xmpp 0.0.10 → 0.0.11

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+**.swp
 .bundle
 .config
 .yardoc

data/README.md

@@ -27,6 +27,15 @@ Or install it yourself as:
 
 ## Usage
 
+XMPP is a stateful asynchronous protocol. Hence, to operate an XMPP client, you
+must be able to receive and send XMPP messages (called stanzas) as well as
+maintain some sort of states at the same time. For this reason, EventMachine is
+a good fit to write and XMPP-client in. EM::Xmpp implements a middleware to
+write XMPP clients on top of EventMachine for the asyncrhonous network, and
+uses Ruby fibers to encapsulate states. Most of the code could easily be
+extracted to work with other backends than EventMachine (e.g., TCPSocket) but
+it would be harder to remove Fibers.
+
 ### Connecting to an XMPP server
 
 Like many EventMachine libraries, you need to first create a module and pass it
@@ -60,6 +69,28 @@ 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.
 
+Summarizing, when your connection receives a stanza, the stanza is encapsulated
+in a context object and matched against context handlers. Default handlers
+exist for the three main stanza types (presence, iq, and message). For example:
+
+    on_presence do |ctx|
+      some_operation1
+      ctx.env['foo'] = 'bar' #passes the 'bar' to the next stanza matcher
+      ctx #unmodified context
+    end
+
+    on_presence do |ctx|
+      some_operation2
+      ctx.env['foo'] #=> 'bar' 
+      ctx.done! #next stanza matchers will not receive the context
+    end
+
+    on_presence do |ctx|
+      this_code_is_never_called
+      ctx
+    end
+
+
 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
@@ -72,13 +103,65 @@ can use the on_exception(:anything) method.
 
 See the ./samples directory for basic examples.
 
+### Interpreting incoming stanzas
+
+Now that you know how to receive contexts, you also want to read content inside
+the stanza. Contexts have a stanza method to get the Nokogiri representation of
+the stanza XML node (remember that stanzas are XML nodes of an XML stream).
+Therefore, you can read any node/attribute in any XML namespace of the original
+XML node. This way, you have a large control on what to read and you can
+implement XEPs not covered in this piece of code (please share your code).
+
+EM::Xmpp provides some level of abstraction to handle incoming stanzas that can
+support multiple XEPs. Since a single stanza can carry lots of different XEPs,
+single inheritence is not a beautiful option. There are two solutions with a
+slightly different cost-model (expressive+slow and slightly-verbose+fast).
+
+A first solution is to extend each context with methods (one Ruby module per
+XEP).  Unfortunately, extending Ruby objects is expensive in terms of method
+cache.  Extend lets you write code that clearly expresses your intention at the
+expense of some slowness.
+
+    on_message do |ctx|
+      ctx.with(:message) # extends with EM::Xmpp::Context::Contexts::Message
+      ctx.with(:mood)    #                                           Mood
+      #then lets you write:
+      puts ctx.from
+      puts ctx.body
+      puts ctx.mood
+      ctx 
+    end
+This is the "Contexts" method.
+
+A less expensive technique is to create, on demand, some delegators objects for
+every XEPs. Therefore you must always prepend a method call to name the XEP you
+use. We call this method the "Bits" method. Because we support XEPs by bits.
+
+    on_message do |ctx|
+      message = ctx.bit!(:message) # delegate to a EM::Xmpp::Context::Bits::Mood
+      mood    = ctx.bit!(:mood)    #                                        Mood 
+      #then lets you write:
+      puts message.from
+      puts message.body
+      puts mood.mood
+      ctx 
+    end
+
+My preference now goes for the Bits method. Hence, ctx.with will also generate
+and cache a Bits object.  The reasons why I keep both APIs are (a) backward
+compatibility (b) forces implementers of XEPs to write the methods for
+Context::Bits in clean modules.  In the future, we might implement ctx.with
+with Ruby refinements.
+
+
 ### 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.
+It is good to receive stanza and interpret them, but sometimes you also want to
+send data. 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 
@@ -96,23 +179,79 @@ 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
+Sometimes, you expect an answer when sending a stanza. For example, an IQ
+result will come back with the same "id" attribute than the IQ query triggering
+the result. For this specific use case, send_stanza can take a callback as
+block parameter. 
+The syntax becomes:
 
-This library does not manage the roster for you. You will have to
-do this by hand.
+    one_time_handler = send_stanza data do |response_ctx|
+	...
+    end
 
-We do not support but plan to support anonymous login yet.
+Using this syntax will install a one-time handler in the connection handler.
+Currently, there is no timeout on this timer. Therfore, you should get the
+value of the one-time handler and you should remove it yourself if the handler
+never matches any stanza fires.
 
-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. .
+See the ./samples directory for basic examples.
 
+## Features
+
+### Entities
+XMPP defines entities as something with a JID and with which you can interact with.
+In EM::Xmpp, each "from" or "to" field encapsulates the JID into an entity object.
+This lets you write something such as:
+
+    on_presence do |ctx|
+      pre = ctx.bit!(:presence)
+      entity = pre.from #here is your entity object
+      if pre.subscription_request?
+         send_stanza pre.reply('type' => 'subscribed')
+         #here are the nice helper methods
+         entity.subscribe                    	
+         entity.say "hello my new friend"
+         entity.add_to_roster
+      end
+      ctx
+    end
+
+### Stateful Conversations 
+XMPP is inherently asynchronous. Hence, handling
+stateful actions (for example, some XEPs have long request/response flow
+charts) can become tricky. Fortunately, EM::Xmpp proposes an abstraction called
+Conversation to manage. Under the hood, a Conversation is not much more than a
+Fiber plus some wiring.  So far, EM::Xmpp does not route stanza to the
+conversations automagically. You must do this by hand.
+
+For short-lived conversations, when you know that an entity should answer to
+your stanza with a reply stanza (and with same "id" attribute), use the block
+argument of send_stanza.
+
+### Roster management 
+This library provides helpers to add/remove entities from your roster as well
+as helpers to get the roster as a list of contacts.
+
+### Muc
+Good support to join/leave/invite/kick/ban/voice/unvoice/chat with people in MUC rooms.
+
+### PubSub
+Partial support. You can subscribe/unsubscribe/publish/receive items, configure
+subscription or node parameters. The missing part is the on accepting PubSub
+subscriptions.
+
+### File Transfer
+There is enough to support for IBB file transfers.
+
+## Missing
+
+* anonymous login
+* login as XMPP component
+* obnoxious SASL schemes such as X-GOOGLE-TOKEN (should patch ruby-sasl gem)
+
+## FAQ
+
+Ask your questions via GitHub "issues".
 
 ## Contributing
 

data/bin/xmig

@@ -0,0 +1,1099 @@
+$LOAD_PATH.unshift './lib'
+require 'em-xmpp'
+require 'em-xmpp/helpers'
+require 'em-xmpp/conversation'
+
+
+if ARGV.empty?
+  puts "usage: #{__FILE__} <jid> <pass|passfile> <cmd>"
+  exit 0 
+end
+
+jid     = ARGV.first
+pass    = if File.file? ARGV[1]
+            File.read ARGV[1]
+          else
+            ARGV[1]
+          end
+
+class CommandParseError < ArgumentError
+end
+
+module Command extend self
+
+  def parse_formdata(allfields)
+    allfields.split('&').map do |onefield|
+      var,type,*values = onefield.split(',')
+      EM::Xmpp::Context::Contexts::Dataforms::Field.new(var,type,nil,values)
+    end
+  end
+
+  def print_dataform(form)
+    puts "# #{form.title}" if form.title
+    puts "#{form.instructions}" if form.instructions
+    form.fields.each_with_index do |field,fidx|
+      puts "#{fidx}) #{field.label || '_'} (#{field.var}/#{field.type})"
+      letter = 'a'
+      field.options.each do |opt| 
+        puts "#{fidx}.#{letter}) #{opt.value} -- #{opt.label || '_'}"
+        letter = letter.succ
+      end
+      field.values.each do |val| 
+        puts "> #{val}"
+        letter = letter.succ
+      end
+    end
+  end
+
+  def print_context_dataforms(ctx)
+    df = ctx.bit!(:dataforms)
+    df.x_forms.each do |form|
+      print_dataform form
+    end
+  end
+
+
+  def for(str)
+    cmd,param = str.split(':',2)
+    case cmd
+
+    when 'quit'
+      lambda do |client|
+        client.quit
+      end
+
+    when 'set'
+      key,val = param.split(':', 2)
+      lambda do |client|
+        client.set(key,val)
+      end
+
+    when 'roster','list-roster','show-roster'
+      lambda do |client|
+        roster = client.get_roster
+        puts "Buddy list:"
+        groups = roster.map(&:groups).flatten.uniq
+        puts "==== No Group ==="
+        items = roster.select{|i| i.groups.empty?}
+        items.each do |item|
+          puts "#{item.name||item.jid} -- #{item.jid} (#{item.type})"
+        end
+
+        groups.each do |group|
+          puts "==== #{group} === "
+          items = roster.select{|i| i.groups.include?(group)}
+          items.each do |item|
+            puts "#{item.jid} -- #{item.name} (#{item.type})"
+          end
+        end
+      end
+
+    when 'unsubscribe', 'unsubscribe-from'
+      lambda do |client|
+        puts "unsubscribing from: #{param}"
+        client.entity(param).unsubscribe
+        client.entity(param).remove_from_roster
+      end
+
+    when 'subscribe', 'subscribe-to'
+      lambda do |client|
+        puts "subscribing to: #{param}"
+        client.entity(param).subscribe
+        client.entity(param).add_to_roster
+      end
+
+    when 'subscribed', 'accept-subscription'
+      lambda do |client|
+        puts "accept subscription from: #{param}"
+        client.entity(param).accept_subscription
+      end
+
+      ### PUBSUB
+      ###### Service user
+
+    when 'pubsub-service-subscriptions'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "=== PubSub Subscriptions on #{jid} (#{node}) ==="
+        ctx = client.entity(jid).pubsub(node).service_subscriptions
+        ctx.bit!(:pubsub).subscriptions.each do |s|
+          puts "#{s.node} -- #{s.subscription} (#{s.sub_id})"
+        end
+      end
+    when 'pubsub-service-affiliations'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "=== PubSub Affiliations on #{jid} (#{node}) ==="
+        ctx = client.entity(jid).pubsub(node).service_affiliations
+        ctx.bit!(:pubsub).affiliations.each do |s|
+          puts "#{s.node} (#{s.affiliation})"
+        end
+      end
+    when 'psubscribe','pubsub-subscribe'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "subscribing to PubSub: #{jid} (#{node})"
+        client.entity(jid).pubsub(node).subscribe
+      end
+    when 'punsubscribe','pubsub-unsubscribe'
+      jid,node,subid = param.split(':',3)
+      lambda do |client|
+        puts "unsubscribing from PubSub: #{jid} (#{node}:#{subid})"
+        client.entity(jid).pubsub(node).unsubscribe(subid)
+      end
+    when 'subscription-options'
+      jid,node,subid = param.split(':',3)
+      lambda do |client|
+        puts "listing options of subscription on: #{jid} (#{node})"
+        ctx = client.entity(jid).pubsub(node).subscription_options(subid)
+        puts "=== PubSub subscription options form ==="
+        Command.print_context_dataforms ctx
+      end
+    when 'pubsub-subscription-default-options'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "listing default subscription options of: #{jid} (#{node})"
+        entity = client.entity(jid).pubsub
+        entity = entity.node(node) if node
+        ctx = entity.default_subscription_configuration
+        puts "=== PubSub default subscription options ==="
+        Command.print_context_dataforms ctx
+      end
+    when 'pubsub-configure-subscription'
+      jid,node,formdata = param.split(':',3)
+      lambda do |client|
+        fields = Command.parse_formdata formdata
+        form = EM::Xmpp::Context::Contexts::Dataforms::Form.new('submit', fields)
+        puts "configuring #{fields.size} fields of subscription: #{jid} (#{node})"
+        ctx = client.entity(jid).pubsub(node).configure_subscription(form)
+      end
+    when 'pubsub-items'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "request items from PubSub: #{jid} (#{node})"
+        client.entity(jid).pubsub(node).items
+      end
+
+      ###### Node owner
+
+    when 'publish'
+      jid,node,payload = param.split(':',3)
+      payload ||= "empty-payload"
+      lambda do |client|
+        puts "publishing #{payload.size} bytes to #{jid} (#{node})"
+        ctx = client.entity(jid).pubsub(node).publish(payload)
+        ctx.bit!(:pubsub).items.each do |item|
+          puts "published: #{item.item_id} at #{item.node}"
+        end
+      end
+    when 'retract'
+      jid,node,item_id = param.split(':',3)
+      lambda do |client|
+        puts "retracting #{item_id} from #{jid} (#{node})"
+        ctx = client.entity(jid).pubsub(node).retract(item_id)
+      end
+    when 'create'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "creating PubSub node: #{jid} (#{node})"
+        client.entity(jid).pubsub(node).create
+      end
+    when 'purge'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "purging PubSub node: #{jid} (#{node})"
+        client.entity(jid).pubsub(node).purge
+      end
+    when 'delete'
+      jid,node,uri = param.split(':',3)
+      lambda do |client|
+        puts "delete PubSub node: #{jid} (#{node})"
+        client.entity(jid).pubsub(node).delete(uri)
+      end
+    when 'pubsub-node-subscriptions'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "=== PubSub Subscriptions on #{jid} ==="
+        ctx = client.entity(jid).pubsub(node).subscriptions
+        ctx.bit!(:pubsubowner).subscriptions.each do |s|
+          puts "#{s.jid} -- #{s.subscription} (#{s.sub_id})"
+        end
+      end
+    when 'pubsub-node-affiliations'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "=== PubSub Affiliations on #{jid} ==="
+        ctx = client.entity(jid).pubsub(node).affiliations
+        ctx.bit!(:pubsubowner).affiliations.each do |s|
+          puts "#{s.jid} (#{s.affiliation})"
+        end
+      end
+
+    when 'pubsub-node-options'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "listing PubSub node configuration options: #{jid} (#{node})"
+        ctx = client.entity(jid).pubsub(node).configuration_options
+        puts "=== PubSub node configuration options form ==="
+        Command.print_context_dataforms ctx
+      end
+
+    when 'pubsub-configure-node'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        ctx = client.entity(jid).pubsub(node).configuration_options
+        client.default_dataform_conversation(ctx,"=== Configuring PubSub node ===") do |proceed,state|
+          client.entity(jid).pubsub(node).configure(state.answers) if proceed
+        end
+      end
+
+    when 'pubsub-node-default-options'
+      jid,node = param.split(':',2)
+      lambda do |client|
+        puts "listing default PubSub node configuration options: #{jid} (#{node})"
+        ctx = client.entity(jid).pubsub(node).default_configuration
+        puts "=== PubSub default node configuration options form ==="
+        Command.print_context_dataforms ctx
+      end
+
+    when 'pubsub-send-node-configuration'
+      jid,node,formdata = param.split(':',3)
+      lambda do |client|
+        fields = Command.parse_formdata formdata
+        form = EM::Xmpp::Context::Contexts::Dataforms::Form.new('submit', fields)
+        puts "configuring #{fields.size} fields of node: #{jid} (#{node})"
+        ctx = client.entity(jid).pubsub(node).configure(form)
+      end
+
+    when 'pubsub-node-change-affiliation'
+      jid,node,affilee,aff = param.split(':',4)
+      lambda do |client|
+        puts "changing affiliation of #{affilee} to #{aff} on #{jid} (#{node})"
+        affiliation = EM::Xmpp::Context::Contexts::PubsubMain::Affiliation.new(affilee,node,aff)
+        ctx = client.entity(jid).pubsub(node).modify_affiliations([affiliation])
+      end
+
+    when 'pubsub-node-change-subscription'
+      jid,node,subscribee,sub_type,subid = param.split(':',5)
+      lambda do |client|
+        puts "changing subscription of #{subscribee} (#{subid}) to #{sub_type} on #{jid} (#{node})"
+        subscription = EM::Xmpp::Context::Contexts::PubsubMain::Subscription.new(subscribee,node,sub_type,subid)
+        ctx = client.entity(jid).pubsub(node).modify_subscriptions([subscription])
+      end
+
+    when 'pubsub-node-delete-affiliation'
+      jid,node,affilee = param.split(':',3)
+      lambda do |client|
+        puts "removing affiliation of #{affilee} on #{jid} (#{node})"
+        ctx = client.entity(jid).pubsub(node).delete_affiliations(affilee)
+      end
+
+    when 'pubsub-node-delete-subscription'
+      jid,node,subscribee,subid = param.split(':',4)
+      lambda do |client|
+        puts "deleting subscription of #{subscribee} (#{subid}) on #{jid} (#{node})"
+        ctx = client.entity(jid).pubsub(node).delete_subscriptions(subscribee,subid)
+      end
+
+      ### MUC
+
+    when 'join-muc'
+      muc,nick = param.split(':',2)
+      lambda do |client|
+        puts "joining MUC: #{muc} as #{nick}"
+        client.entity(muc).muc.join(nick)
+      end
+
+    when 'leave-muc', 'part'
+      muc,nick = param.split(':',2)
+      lambda do |client|
+        puts "leaving MUC: #{muc}"
+        client.entity(muc).muc.part(nick)
+      end
+
+    when 'invite-to-muc'
+      muc,nick = param.split(':',2)
+      lambda do |client|
+        puts "inviting #{nick} to #{muc}"
+        client.entity(muc).muc.invite(nick)
+      end
+
+    when 'say', 'tell', 'message', 'msg'
+      dst,msg = param.split(':',2)
+      lambda do |client|
+        puts "speaking to: #{dst}"
+        client.entity(dst).say(msg)
+      end
+
+    when 'buzzmsg'
+      dst,msg = param.split(':',2)
+      lambda do |client|
+        puts "speaking to: #{dst}"
+        client.entity(dst).say(msg,'chat',lambda{|xml| xml.attention(:xmlns => EM::Xmpp::Namespaces::Attention)})
+      end
+
+    when 'avatar'
+      path = param
+      lambda do |client|
+        mime ||= "image/png" #TODO get mime
+        dat = File.read(path)
+        item = EM::Xmpp::Entity::Avatar::Item.new(nil,dat,16,16,mime)
+        puts "sending avatar"
+        ctx = client.jid.bare.avatar.publish item
+      end
+    when 'delete-avatar'
+      lambda do |client|
+        puts "sending avatar"
+        ctx = client.jid.bare.avatar.remove
+      end
+
+    when 'smiley'
+      dst,path,mime = param.split(':',2)
+      lambda do |client|
+        mime ||= "image/png" #TODO get mime
+        dat = File.read(path)
+        item = EM::Xmpp::Context::Contexts::Bob::Item.new(client.jid,dat,mime,65535)
+
+        puts "sending smiley to: #{dst}"
+        xmlproc = lambda do |xml| 
+          xml.body "smiley"
+          xml.html(:xmlns => EM::Xmpp::Namespaces::XhtmlIM) do |html|
+            html.body(:xmlns => 'http://www.w3.org/1999/xhtml') do |body|
+              body.img('alt' => 'smiley', 'src'=>"cid:#{item.cid}")
+            end
+          end
+        end
+
+        client.entity(dst).say("",'chat', xmlproc)
+        client.on_iq do |ctx|
+          bob = ctx.bit(:bob)
+          if bob and (bob.cid == item.cid)
+            puts "sending bob"
+            iq = bob.reply(item)
+            client.send_stanza iq
+            ctx.delete_xpath_handler!
+            ctx.done!
+          end
+          ctx
+        end
+      end
+
+
+    when 'gsay', 'gtell', 'gmsg'
+      dst,msg = param.split(':',2)
+      lambda do |client|
+        puts "speaking in MUC: #{dst}"
+        client.entity(dst).muc.say(msg)
+      end
+
+    when 'motd','subject'
+      dst,msg = param.split(':',2)
+      lambda do |client|
+        puts "setting motd of: #{dst}"
+        client.entity(dst).muc.motd(msg)
+      end
+
+    when 'nickname','nick'
+      dst,name = param.split(':',2)
+      lambda do |client|
+        puts "using nickname: #{dst}"
+        client.entity(dst).muc.change_nick(name)
+      end
+
+    when 'kick'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "kicking #{user}"
+        client.entity(dst).muc.kick(user)
+      end
+
+    when 'ban'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "banning #{user}"
+        client.entity(dst).muc.ban(user)
+      end
+
+    when 'unban'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "unbanning #{user}"
+        client.entity(dst).muc.unban(user)
+      end
+
+    when 'moderator'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "moddeerating #{user}"
+        client.entity(dst).muc.moderator(user)
+      end
+
+    when 'unmoderator'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "unmoderating #{user}"
+        client.entity(dst).muc.unmoderator(user)
+      end
+
+    when 'admin'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "admin #{user}"
+        client.entity(dst).muc.admin(user)
+      end
+
+    when 'unadmin'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "unadmin #{user}"
+        client.entity(dst).muc.unadmin(user)
+      end
+
+    when 'owner'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "new owner #{user}"
+        client.entity(dst).muc.owner(user)
+      end
+
+    when 'unowner'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "remove owner #{user}"
+        client.entity(dst).muc.unowner(user)
+      end
+
+    when 'voice'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "voicing #{user}"
+        client.entity(dst).muc.voice(user)
+      end
+
+    when 'unvoice'
+      dst,user = param.split(':',2)
+      lambda do |client|
+        puts "unvoicing #{user}"
+        client.entity(dst).muc.unvoice(user)
+      end
+     
+    when 'disco-infos','infos'
+      dst,node = param.split(':',2)
+      lambda do |client|
+        puts "discovering infos for: #{dst} (node:#{node})"
+        disco = client.entity(dst).discover_infos(node)
+
+        puts "=== Identities ==="
+        disco.bit!(:discoinfos).identities.each do |i|
+          puts "#{i.category}/#{i.type}: #{i.name || "_"}"
+        end
+        puts "=== Features ==="
+        disco.bit!(:discoinfos).features.each do |f|
+          puts "#{f.var}"
+        end
+      end
+      
+    when 'disco-items','items'
+      dst,node = param.split(':',2)
+      lambda do |client|
+        puts "discovering items for: #{dst} (node:#{node})"
+        disco = client.entity(dst).discover_items(node)
+
+        puts "=== Items ==="
+        disco.bit!(:discoitems).items.each do |i|
+          puts "#{i.entity} (#{i.node}) -- #{i.name || i.entity}"
+        end
+      end
+
+      # file-transfer
+    when 'send-file'
+      jid,path,txt,formdata = param.split(':',3)
+      sid = "ft_#{rand(65535)}"
+      lambda do |client|
+        form = if formdata
+                 puts "configuring #{fields.size} fields to propose transfer: #{jid}"
+                 fields = Command.parse_formdata formdata
+                 EM::Xmpp::Context::Contexts::Dataforms::Form.new('submit', fields)
+               else
+                 puts "using default form"
+                 fields = [EM::Xmpp::Context::Contexts::Dataforms::Field.new(
+                   'stream-method',
+                   'list-single',
+                   nil, #user-friendly label
+                   [],  #current values
+                   [EM::Xmpp::Namespaces::IBB] #available options
+                 )
+                 ]
+                 EM::Xmpp::Context::Contexts::Dataforms::Form.new('submit', fields)
+               end
+        desc = EM::Xmpp::Entity::Transfer.describe_file path
+        desc[:description] = txt
+        ctx = client.entity(jid).transfer.negotiation_request(desc,sid,form)
+        if ctx.bit(:iq).type == 'result'
+          method = ctx.bit(:dataforms).x_forms.first.fields.find{|f| f.var == 'stream-method'}
+          puts "accepted transfer via #{method.value}" if method
+          case method.value
+          when EM::Xmpp::Namespaces::IBB
+            key = client.ibb_conversation_key_for_sid(ctx.bit(:stanza), sid)
+            ctx.env['path']       = path
+            ctx.env['stream.id']  = sid
+            ctx.env['peer']       = ctx.bit(:iq).from
+            client.ibb_ul_conversation(ctx,key) do |step|
+              step.on(:start) do
+                puts "=== Starting Upload ==="
+              end
+              step.on(:cancel) do
+                puts "=== Upload canceled ==="
+              end
+              step.on(:chunk) do |state|
+                puts "=== Outgoing chunk #{state.last_chunk.size} bytes ==="
+              end
+              step.on(:done) do
+                puts "=== Upload Finished ==="
+              end
+            end
+          else
+            puts "unsupported method, will have to cancel"
+          end
+        else
+          puts "refused"
+        end
+      end
+    when 'receive-file'
+      jid,id,formdata = param.split(':',3)
+      lambda do |client|
+        fields = Command.parse_formdata formdata
+        form = EM::Xmpp::Context::Contexts::Dataforms::Form.new('submit', fields)
+        puts "configuring #{fields.size} fields to accept transfer: #{jid}"
+        client.entity(jid).transfer.negotiation_reply(id,form)
+      end
+    when 'iq'
+      jid,iq_type,iq_id = param.split(':',3)
+      lambda do |client|
+        puts "sending iq (#{iq_type}/#{iq_id})"
+        args = {'to' => jid, 'type' => iq_type, 'id' => iq_id}
+        iq = client.iq_stanza(args)
+        client.send_stanza iq
+      end
+    when 'conversations'
+      lambda do |client|
+        client.conversations.keys.each do |conv|
+          puts conv
+        end
+      end
+    else
+      raise CommandParseError, "doesn't know such command: #{cmd}"
+    end
+  end
+end
+
+commands = ARGV[2 .. -1]
+
+module RosterClient
+  include EM::Xmpp::Helpers
+  attr_reader :queue
+
+  def ready
+    @show_xml = false
+    puts "***** #{@jid} ready"
+    user_data.each{|c| handle_command c}
+    EM.open_keyboard Kb, self
+
+    # Writes a stack-trace on error
+    on_exception(:anything) do |ctx|
+      raise ctx['error']
+    end
+
+
+    # Signal presence subscriptions
+    on_presence do |ctx|
+      pre = ctx.bit!(:presence)
+      if pre.subscription_request?
+        puts "=== Presence subscription request from: #{pre.from.bare}"
+        ctx.done!
+      end
+      ctx
+    end
+
+    # Signal people arriving and leaving
+    on_presence do |ctx|
+      pre = ctx.bit!(:presence)
+      puts "=== Presence #{pre.from}: #{pre.type}"
+      ctx.done!
+    end
+
+    # Acknowledge roster change 
+    on_iq do |ctx|
+      roster = ctx.bit(:roster)
+      if roster
+        if roster.type == 'set'
+          puts "=== Roster change ==="
+          roster.items.each do |item|
+            puts "#{item.name||item.jid} -- #{item.jid} (#{item.type})"
+          end
+          send_stanza roster.reply
+          ctx.done!
+        end
+      end
+      ctx
+    end
+
+    # Replies to item queries
+    on_iq do |ctx|
+      query = ctx.bit(:discoitems)
+      if query
+        list = items(query.to,query.node)
+        puts "==== #{query.from} discovers #{list.size} items at node #{query.node} ==="
+        reply = query.reply do |iq|
+          iq.query(:xmlns => EM::Xmpp::Namespaces::DiscoverItems,
+                   :node => EM::Xmpp::Namespaces::Commands) do |q|
+            list.each do |item|
+              q.item('jid' => item.entity, 'node'=> item.node, 'name'=>item.name)
+            end
+          end
+        end
+        send_stanza reply
+        ctx.done!
+      end
+      ctx
+    end
+
+
+    # Replies to command queries
+    on_iq do |ctx|
+      query = ctx.bit(:command)
+
+      if query
+        if query.sessionid
+          key = "command:#{query.from}:#{query.node}:#{query.sessionid}"
+          conv = conversation(key)
+          conv.resume ctx if conv
+          #else returns an error
+        else
+          puts "=== Calling command on behalf of #{query.from} ==="
+          sess_id = "cmd:#{ctx.object_id}"
+          key     = "command:#{query.from}:#{query.node}:#{sess_id}"
+
+          fields = [EM::Xmpp::Context::Contexts::Dataforms::Field.new(
+            'stream-method',
+            'list-single',
+            "Stream Method", #user-friendly label
+            ['foo'],  #current values
+            ['opt1','opt2','opt3'] #available options
+          ),
+          EM::Xmpp::Context::Contexts::Dataforms::Field.new(
+            'bar',
+            'boolean',
+            "True/False", #user-friendly label
+            ['0'],  #current values
+            [],
+          )
+          ]
+          form = EM::Xmpp::Context::Contexts::Dataforms::Form.new('form', fields,"please answer", "just fill-in the values")
+          result = EM::Xmpp::Context::Contexts::Dataforms::Form.new('result', fields)
+
+          step1 = CommandStep.new(form)
+          spec  = LinearCommandsSpec.new([step1]) #actually pick it from query. node
+
+          start_command_conversation(ctx,key,sess_id,spec) do |step|
+            step.on(:start) do |state|
+              state.flash = CommandFlash.new :info, "some info"
+            end
+            step.on(:answer) do |state|
+              action = state.last_answer.ctx.bit(:command).action
+              puts "user answered (#{action})"
+              Command.print_context_dataforms state.last_answer.ctx
+              state.flash = CommandFlash.new :info, "some other info"
+              state.status = :executing
+              state.current_idx += 1
+              state.result = result
+            end
+            step.on(:cancel) do |state|
+              puts "cancelled"
+            end
+          end
+        end
+        ctx.done!
+      end
+      ctx
+    end
+
+    # Prints Pubsub event
+    on_message do |ctx|
+      event = ctx.bit(:pubsubevent)
+      delay = ctx.bit(:delay)
+      stamp = delay.stamp if delay
+      if event
+        puts "=== PubSub event #{event.service} #{stamp} ==="
+        if event.items_node #oddly enough, retractions fall in items_node
+          items       = event.items
+          retractions = event.retractions
+
+          if items.any? or retractions.any?
+            items.each do |i|
+              puts "+item> #{i.node} #{i.item_id} (by #{i.publisher || 'N/A'})"
+              puts i.payload
+            end
+
+            event.retractions.each do |r|
+              puts "-item> #{r.node} #{r.item_id}"
+            end
+          else
+            puts "empty items list for #{event.node_id}"
+          end
+        end
+
+
+        if event.purge
+          puts "node purged #{event.purge.node}"
+        end
+
+        if event.deletion
+          del = event.deletion
+          puts "node destroyed #{del.node}"
+          puts "  now redirects to #{del.redirect}" if del.redirect
+        end
+
+        if event.configuration
+          cfg = event.configuration
+          puts "new node configuration for #{cfg.node}"
+          Command.print_context_dataforms(ctx)
+        end
+
+        ctx.done!
+      end
+
+      event = ctx.bit(:pubsub)
+      if event
+        puts "=== PubSub #{event.service} ==="
+        event.subscriptions.each do |sub|
+          puts "subscription of #{sub.jid} (#{sub.sub_id}) status is now #{sub.subscription} for #{sub.node}"
+          puts "expires on #{sub.expiry}" if sub.expiry
+        end
+        ctx.done!
+      end
+      ctx
+    end
+
+    on_iq do |ctx|
+      si =  ctx.bit(:streaminitiation)
+      if si
+        puts "=== FileTransfer request from #{si.from}:#{si.id} ==="
+        puts "file details: #{si.file_name} (#{si.file_size} bytes) (mime:#{si.mime_type})"
+        puts "description: #{si.description}" if si.description
+
+        default_dataform_conversation(ctx, "Negotiating stream") do |proceed,state|
+          if proceed
+            si.from.transfer.negotiation_reply(si.id, state.answers)
+          else
+            send_stanza si.reply(:type => 'error')
+          end
+        end
+
+        ctx.done!
+      end
+      ctx
+    end
+
+    on_iq do |ctx|
+      ibb = ctx.bit(:ibb)
+      if ibb
+        key = ibb_conversation_key(ibb)
+
+        if ibb.open_node
+          ibb_dl_conversation(ctx,key) do |step|
+            step.on(:start) do
+              puts "=== FileTransfer IBB starting (sid: #{ibb.sid}) ==="
+            end
+            step.on(:cancel) do
+              puts "=== Canceled FileTransfer (sid: #{ibb.sid}) ==="
+            end
+            step.on(:chunk) do |state|
+              puts "=== Incoming chunk (#{state.last_chunk.size} bytes) (sid:#{ibb.sid})"
+            end
+            step.on(:done) do
+              puts "=== FileTransfer IBB done (sid: #{ibb.sid}) ==="
+            end
+          end
+        else
+          conv = conversation(key)
+          conv.resume ctx if conv
+        end
+        ctx.done!
+      end
+      ctx
+    end
+  end
+
+  # list of supported items for the given node
+  def items(jid,node)
+    #TODO: correctly pick items from the jid/node name
+    [EM::Xmpp::Context::Contexts::Discoitems::Item.new(jid.full, 'cmd:1','a first command'),
+    EM::Xmpp::Context::Contexts::Discoitems::Item.new(jid.full, 'cmd:2','anoter command')]
+  end
+
+  def ibb_conversation_key(ibb)
+    ibb_conversation_key_for_sid ibb, ibb.sid
+  end
+
+  def ibb_conversation_key_for_sid(x,sid)
+    [ 'ibb', x.from , sid ].map(&:to_s).join('|')
+  end
+
+  IBBDLState = Struct.new(:buffer, :last_iq, :done, :last_chunk)
+  IBBULState = Struct.new(:jid, :sid, :chunk_size, :ptr, :chunk_idx, :done, :last_chunk, :closed)
+
+  def ibb_ul_conversation(initial_ctx,key,&blk)
+    path = initial_ctx.env['path']
+    sid  = initial_ctx.env['stream.id']
+    jid  = initial_ctx.env['peer']
+
+    #encode data
+    raw_data = File.read path
+    data     = Base64.strict_encode64 raw_data
+
+    state = IBBULState.new(jid,sid,4096,0,0,false,false,false)
+
+    start_conversation(initial_ctx,key,state) do |conv|
+      conv.prepare_callbacks(:start, :cancel, :chunk, :done, &blk)
+
+      catch :interrupt do 
+        # opens transfer
+        iq = iq_stanza(:type => 'set', 'to' => state.jid, 'id' => "tx.#{sid}.#{state.ptr}") do |xml|
+          xml.open('xmlns' => EM::Xmpp::Namespaces::IBB, 'block-size' => state.chunk_size, 'sid' => state.sid, 'stanza' => 'iq')
+        end
+        ret = conv.send_stanza iq, 10
+
+        if ret.interrupted?
+          rsp = ret.ctx.bit(:iq)
+          if rsp.type == 'error'
+            conv.callback :cancel
+            throw :interrupt
+          else
+            conv.callback :start
+          end
+        else
+          conv.callback :cancel
+          throw :interrupt
+        end
+
+        # uploads all chunk
+        until state.done or state.closed do
+          # send a chunk of encoded data and wait for an ack
+          blk = data.slice(state.ptr, state.chunk_size)
+          state.last_chunk = blk
+          iq = iq_stanza(:type => 'set', 'to' => state.jid, 'id' => "tx.#{sid}.#{state.ptr}") do |xml|
+            xml.data({'xmlns' => EM::Xmpp::Namespaces::IBB, 'sid' => state.sid, 'seq' => state.chunk_idx}, blk)
+          end
+
+          ret = conv.send_stanza iq
+          iq = ret.ctx.bit(:iq)
+          case iq.type 
+          when 'result'
+            #nothing
+          when 'set'
+            ibb = ret.ctx.bit(:ibb)
+            if ibb.close_node #other end closes, but there is still a non-acknowledge pending iq
+              conv.send_stanza iq.reply, 1
+              state.closed = true
+            end
+          else
+            conv.callback :cancel
+            throw :interrupt
+          end
+
+          conv.callback :chunk
+          state.ptr += state.chunk_size
+          state.chunk_idx += 1
+          state.done = true if state.ptr > data.size
+        end
+
+        unless state.closed
+          # notify the end of the IBB
+          iq = iq_stanza(:type => 'set', 'to' => state.jid) do |xml|
+            xml.close('xmlns' => EM::Xmpp::Namespaces::IBB, 'sid' => state.sid)
+          end
+          conv.send_stanza iq, 1
+        end
+
+        conv.callback :done
+      end # catch :interrupt
+    end
+  end
+
+  def ibb_dl_conversation(initial_ctx,key,&blk)
+    state = IBBDLState.new("", initial_ctx.bit(:iq), false, nil)
+
+    start_conversation(initial_ctx,key,state) do |conv|
+      conv.prepare_callbacks(:start, :cancel, :chunk, :done, &blk)
+
+      conv.callback :start
+
+      until state.done do
+        # ack last iq
+        send_stanza state.last_iq.reply
+
+        # expect some data chunk, may wait forever
+        chunk_ctx = conv.delay.ctx
+        chunk         = chunk_ctx.bit(:ibb)
+        state.last_iq = chunk_ctx.bit(:iq)
+
+        # we should either have a final node or some data
+        if chunk.close_node
+          state.done = true
+          conv.callback :done
+        else
+          state.last_chunk = chunk.data
+          state.buffer << chunk.data
+          conv.callback :chunk
+        end
+      end
+
+      send_stanza state.last_iq.reply
+    end
+  end
+
+  def default_dataform_conversation(ctx, banner, &action)
+    ctx.env['dataform'] = ctx.bit!(:dataforms).form
+    dataform_conversation(ctx) do |step|
+      step.on(:start) do
+        puts banner
+      end
+
+      step.on(:confirm) do |state|
+        puts "Ready to submit:"
+        Command.print_dataform state.answers
+        puts "Submit? Y/n"
+      end
+
+      step.on(:user_answer) do |state|
+        txt = state.user_input
+        case txt 
+        when ':cancel'
+          :cancel
+        when ':prev',':previous'
+          :previous
+        when ':next',''
+          values = state.current_response_values
+          response_field = EM::Xmpp::Context::Contexts::Dataforms::Field.new(state.current_field.var,nil,nil,values,[])
+          state.answers.fields[state.current_idx] = response_field
+          :next
+        when /^:\d+\.(\w+)$/ #answers to a question by response ID
+          option_code = Regexp.last_match[1]
+          field = state.current_field
+          letter = 'a'
+          opt = field.options.find do |o|
+            found   = letter == option_code
+            letter  = letter.succ
+            found
+          end
+
+          if opt
+            values = [opt.value]
+            response_field = EM::Xmpp::Context::Contexts::Dataforms::Field.new(state.current_field.var,nil,nil,values,[])
+            state.answers.fields[state.current_idx] = response_field
+            :modified
+          else
+            :repeat
+          end
+        else
+          values = [txt]
+          response_field = EM::Xmpp::Context::Contexts::Dataforms::Field.new(state.current_field.var,nil,nil,values,[])
+          state.answers.fields[state.current_idx] = response_field
+          :modified
+        end
+      end
+
+      step.on(:ask) do |state|
+        fidx  = state.current_idx
+        field = state.current_field
+
+        puts "#{fidx+1}/#{state.form.fields.count}) #{field.label || '_'} (#{field.var}/#{field.type})"
+        letter = 'a'
+        field.options.each do |opt| 
+          puts "#{fidx+1}.#{letter}) #{opt.value} -- #{opt.label || '_'}"
+          letter = letter.succ
+        end
+
+        if state.current_response_values.any?
+          puts "Current response value:"
+          state.current_response_values.each do |val| 
+            puts "#{val}"
+            letter = letter.succ
+          end
+        end
+        puts "Enter your choice:"
+      end
+
+      step.on(:submit) do |state|
+        if state.user_input == 'n'
+          puts "Cancelled"
+          action.call(false, state)
+        else
+          puts "Proceeding"
+          action.call(true, state)
+        end
+      end
+
+      step.on(:cancel) do |state|
+        puts "Cancelled"
+        action.call(false, state)
+      end
+    end
+  end
+
+  def stanza_end(stanza)
+    puts stanza if @show_xml
+    super
+  end
+
+  def handle_command(str)
+    begin
+      if conversation(:dataform)
+        conversation(:dataform).resume str
+      else
+        Command.for(str).call self unless str.empty?
+      end
+    rescue CommandParseError
+      puts "could not parse #{str}"
+    end
+  end
+
+  def quit
+    close_xml_stream
+    close_connection
+  end
+
+  def set(key,val)
+    case key
+    when '+xml'
+      @show_xml = true
+    when '-xml'
+      @show_xml = false
+    when '+debug'
+      @show_xml = false
+      $DEBUG = true
+    when '-debug'
+      $DEBUG = false
+    end
+  end
+
+  def unbind
+    EM.stop
+  end
+end
+
+class Kb < EM::Connection
+  include EM::Protocols::LineText2
+  def initialize(client)
+    @client = client
+  end
+  def receive_line line
+    Fiber.new { @client.handle_command line.chomp}.resume
+  end
+end
+
+EM.run do
+  EM::Xmpp::Connection.start(jid, pass, RosterClient, {:data => commands})
+  puts "***** connecting as #{jid}"
+end