em-xmpp 0.0.11 → 0.0.12

data/lib/em-xmpp/helpers.rb

@@ -1,18 +1,19 @@
 
+require 'em-xmpp/namespaces'
 require 'em-xmpp/nodes'
 require 'em-xmpp/conversation'
+require 'fiber'
+
 module EM::Xmpp
   module Helpers
     include EM::Xmpp::Namespaces
     def get_roster
       f = Fiber.current
 
-      roster = iq_stanza do |iq|
-        iq.query(:xmlns => Roster)
-      end
+      roster = iq_stanza(x('query',:xmlns => Roster))
 
       send_stanza(roster) do |response|
-        f.resume response.bit!(:roster).items
+        f.resume response.bit(:roster).items
       end
 
       Fiber.yield
@@ -158,17 +159,17 @@ module EM::Xmpp
           until state.finished?
             state.status = 'executing'
 
-            reply = query.reply do |iq|
-              iq.command(:xmlns => EM::Xmpp::Namespaces::Commands, :sessionid => sess_id, :node => query.node, :status => state.status) do |cmd|
-                cmd.actions do |n|
-                  n.prev     if state.can_prev?
-                  n.complete if state.can_complete?
-                  n.next     if state.can_next?
-                end
-                build_form(cmd, state.form,'form')
-                cmd.note({:type => state.flash.level}, state.flash.msg) if state.flash
-              end
-            end
+            reply = query.reply(
+              x('command',{:xmlns => EM::Xmpp::Namespaces::Commands, :sessionid => sess_id, :node => query.node, :status => state.status},
+                x('actions',
+                  x_if(state.can_prev?,'prev'),
+                  x_if(state.can_complete?,'complete'),
+                  x_if(state.can_next?,'next')
+                ),
+                build_form(state.form,'form'),
+                x_if(state.flash,'note',{:type => state.flash.level}, state.flash.msg)
+              )
+            )
 
             user_answer       = conv.send_stanza reply
             state.last_answer = user_answer
@@ -187,40 +188,40 @@ module EM::Xmpp
           state.status = 'completed'
         end
 
-        finalizer = state.last_answer.ctx.bit(:command).reply do |iq|
-          iq.command(:xmlns => EM::Xmpp::Namespaces::Commands, :sessionid => sess_id, :node => query.node, :status => state.status) do |cmd|
-            cmd.note({:type => state.flash.level}, state.flash.msg) if state.flash
-            build_form(cmd, state.result,'result') if state.result
-          end
-        end
+        finalizer = state.last_answer.ctx.bit(:command).reply(
+          x('command',{:xmlns => EM::Xmpp::Namespaces::Commands, :sessionid => sess_id, :node => query.node, :status => state.status},
+            x_if(state.flash,'note',{:type => state.flash.level}, state.flash.msg),
+            state.result ? build_form(state.result,'result') : nil
+          )
+        )
         send_stanza finalizer
       end
     end
 
-    def build_form(xml,form,type='submit')
-      xml.x(:xmlns => DataForms, :type => type) do |x|
-        x.title form.title if form.title
-        x.instructions form.instructions if form.instructions
-        form.fields.each do |field|
+    def build_form(form,type='submit')
+      x('x',{:xmlns => DataForms, :type => type},
+        x_if(form.title,'title',form.title),
+        x_if(form.instructions,'instructions',form.instructions),
+        form.fields.map do |field|
           args = {'var' => field.var}
           args = args.merge('type' => field.type) unless field.type.nil? or field.type.empty?
           args = args.merge('label' => field.label) unless field.label.nil? or field.label.empty?
-          x.field(args) do |f|
-            (field.options||[]).each do |opt_value|
-              f.option do |o|
-                o.value opt_value
-              end
-            end
-            (field.values||[]).each do |value|
-              f.value value
+          x('field',args,
+            (field.options||[]).map do |opt_value|
+              x('option',
+                x('value',opt_value)
+              )
+            end,
+            (field.values||[]).map do |value|
+              x('value',value)
             end
-          end
+          )
         end
-      end
+      )
     end
 
-    def build_submit_form(xml,form)
-      build_form(xml,form,'submit')
+    def build_submit_form(form)
+      build_form(form,'submit')
     end
 
   end

data/lib/em-xmpp/namespaces.rb

@@ -3,6 +3,7 @@ module EM::Xmpp
   # A handy module with the XMPP namespaces name.
   module Namespaces
     Client = 'jabber:client'
+    Component = 'jabber:component'
     #In-band registration
     Registration = 'http://jabber.org/features/iq-register'
     #XMPP stream-level stanza

data/lib/em-xmpp/non-em.rb

@@ -0,0 +1,95 @@
+
+require 'em-xmpp'
+require 'em-xmpp/namespaces'
+require 'em-xmpp/evented'
+require 'em-xmpp/jid'
+require 'em-xmpp/component'
+require 'em-xmpp/resolver'
+
+require 'socket'
+require 'openssl'
+
+module EM::Xmpp
+  module NonEM
+    class Connection
+      include Namespaces
+      include Evented
+
+      attr_reader :jid, :pass, :user_data
+
+      def initialize(jid, pass, mod=nil, cfg={})
+        @jid        = jid
+        @component  = jid.node.nil?
+        self.extend Component if component?
+        @pass       = pass.dup.freeze
+        self.extend mod if mod
+        certdir     = cfg[:certificates]
+        @user_data  = cfg[:data]
+        @certstore  = if certdir
+                        CertStore.new(certdir)
+                      else
+                        nil
+                      end
+        @ssl        = nil
+      end
+
+      def self.start(jid, pass=nil, mod=nil, cfg={}, server=nil, port=5222, &blk)
+        jid = JID.parse jid
+        if server.nil?
+          record = Resolver.resolve jid.domain
+          if record
+            server = record.target.to_s
+            port   = record.port
+          else
+            server = jid.domain
+          end
+        end
+        obj = self.new(jid,pass,mod,cfg)
+        obj.start(server,port)
+        obj
+      end
+
+      def start(server,port)
+        @skt = TCPSocket.open(server,port)
+      end
+
+      ChunkSize = 1450
+
+      def event_loop
+        prepare_parser!
+        set_negotiation_handler!
+        catch :stop do
+          loop do
+            tick=5
+            ok = IO.select([@skt], nil, nil, tick)
+            if ok
+              if @ssl
+                dat = @ssl.sysread(ChunkSize)
+                puts "<< in\n#{dat}\n" if $DEBUG
+                receive_raw(dat)
+              else
+                dat = @skt.recv(ChunkSize)
+                puts "<< in\n#{dat}\n" if $DEBUG
+                receive_raw(dat)
+              end
+            end
+          end
+        end
+      end
+
+      def send_raw(dat)
+        puts ">> out\n#{dat}\n" if $DEBUG
+        if @ssl
+          @ssl.syswrite dat
+        else
+          @skt << dat if @skt
+        end
+      end
+
+      def initiate_tls
+        @ssl = OpenSSL::SSL::SSLSocket.new(@skt).connect
+      end
+    end
+  end
+
+end

data/lib/em-xmpp/version.rb

@@ -1,5 +1,5 @@
 module Em
   module Xmpp
-    VERSION = "0.0.11"
+    VERSION = "0.0.12"
   end
 end

data/lib/em-xmpp/xml_builder.rb

@@ -0,0 +1,160 @@
+require 'ox'
+require 'nokogiri'
+
+module Ox
+  module Builder
+    # args = attributes and/or children in any order, multiple appearance is possible
+    # @overload build(name,attributes,children)
+    #   @param [String] name name of the Element
+    #   @param [Hash] attributes
+    #   @param [String|Element|Array] children text, child element or array of elements
+    def x(name, *args)
+      n = Element.new(name)
+      yielded = if block_given?
+                  yield
+                else 
+                  []
+                end
+      unless yielded.is_a?(Array)
+        yielded = [yielded]
+      end
+      values = args + yielded
+
+      values.each do |val|
+        case val
+        when Hash
+          val.each { |k,v| n[k.to_s] = v }
+        when Array
+          val.each { |c| n << c if c}
+        else
+          n << val if val
+        end
+      end
+
+      n
+    end
+    def x_if(condition, *args)
+      x(*args) if condition
+    end
+  end
+end
+
+module Nokogiri::AlternativeBuilder
+  class Element
+    attr_reader :name, :children, :attributes
+    def initialize(name)
+      @name = name
+      @children = []
+      @attributes = {}
+    end
+    def << n
+      @children << n
+    end
+    def []= k,v
+      @attributes[k] = v
+    end
+  end
+
+  def x(name, *args)
+    n = Element.new(name)
+    yielded = if block_given?
+                yield
+              else 
+                []
+              end
+    unless yielded.is_a?(Array)
+      yielded = [yielded]
+    end
+    values = args + yielded
+
+    values.each do |val|
+      case val
+      when Hash
+        val.each { |k,v| n[k.to_s] = v }
+      when Array
+        val.each { |c| n << c if c}
+      else
+        n << val if val
+      end
+    end
+    n
+  end
+  def x_if(condition, *args)
+    x(*args) if condition
+  end
+end
+
+module EM::Xmpp
+  module NokogiriXmlBuilder
+    include Nokogiri::AlternativeBuilder
+    class OutgoingStanza
+      include NokogiriXmlBuilder
+
+      attr_reader :xml,:params
+
+      def initialize(*args,&blk)
+        @root = x(*args,&blk)
+        @doc = build_doc_from_element_root @root
+        @xml = @doc.root.to_xml
+        @params = @root.attributes
+      end
+
+      private
+
+      def build_doc_from_element_root(root)
+        doc = Nokogiri::XML::Document.new
+        root_node = build_tree doc, root
+        doc.root = root_node
+        doc
+      end
+    end
+
+    def build_xml(*args)
+      root = x(*args)
+      doc = Nokogiri::XML::Document.new
+      doc.root = build_tree(doc,  root)
+      ret  = doc.root.to_xml
+      ret
+    end
+
+    private
+
+    def build_tree(doc, node_info)
+      node = node_info
+      if node_info.respond_to?(:name)
+        node = node_for_info doc, node_info
+        list = node_info.children.map{|child| build_tree doc, child}
+        list.each{|l| node << l }
+      end
+      node
+    end
+
+    def node_for_info(doc, node_info)
+      node = Nokogiri::XML::Node.new(node_info.name, doc)
+      node_info.attributes.each_pair {|k,v| node[k] = v}
+      node
+    end
+  end
+
+  module OxXmlBuilder
+    include Ox::Builder
+
+    class OutgoingStanza
+      include OxXmlBuilder
+      attr_reader :xml,:params
+
+      def initialize(*args,&blk)
+        node = x(*args,&blk)
+        @xml = Ox.dump(node)
+        @params = node.attributes
+      end
+    end
+
+    def build_xml(*args)
+      Ox.dump(x(*args))
+    end
+  end
+
+  #XmlBuilder = OxXmlBuilder
+  XmlBuilder = NokogiriXmlBuilder
+end

data/lib/em-xmpp/xml_parser.rb

@@ -0,0 +1,344 @@
+require 'nokogiri'
+require 'ox'
+
+#workarounds
+module Ox
+  module XPathSubset
+    class Query 
+      attr_reader :type, :name, :ns
+      def initialize(t,e,n)
+        @type, @name, @ns = t, e, n
+      end
+
+      def match(elem, ns_mapping)
+        wanted_ns = ns_mapping[ns]
+
+        same_value = elem.value == name 
+        same_ns    = elem.xmlns == wanted_ns
+
+        matching = same_value & same_ns
+      end
+
+      def find(elem, ns_mapping)
+        ret = []
+        ret << elem if match(elem, ns_mapping)
+        case type
+        when 'normal'
+          elem.nodes.reject{|n| n.is_a?(String)}.each do |n|
+            ret << n if match(n, ns_mapping)
+          end
+        when 'relative', 'anywhere' #TODO: for anywhere, should go to the root first, is that even possible?
+          elem.nodes.reject{|n| n.is_a?(String)}.each do |n|
+            find(n, ns_mapping).each {|m| ret << m}
+          end
+        else
+          raise NotImplementedError
+        end
+
+        ret
+      end
+    end
+  end
+
+	class Element
+    attr_accessor :xmlns
+    def parse_xpath(path)
+      queries = path.split('|').map(&:strip).map do |str|
+        kind = if str.start_with?("//")
+                 'anywhere'
+               elsif str.start_with?(".//")
+                 'relative'
+               else
+                 'normal'
+               end
+        ns,name = str.split(':',2)
+        if name
+          ns = ns.tr('/.','')
+        else
+          name,ns = ns,nil unless name
+        end
+        XPathSubset::Query.new(kind, name, ns)
+      end
+    end
+
+		def xpath(path,ns_mapping)
+      queries = parse_xpath(path)
+      elems = []
+      queries.each do |q|
+        q.find(self,ns_mapping).each do |n|
+          elems << n
+        end
+      end
+      elems.uniq
+		end
+
+		def children
+			text ? [] : nodes
+		end
+
+		def content
+			text
+		end
+
+		def any?
+			text
+		end
+
+    def child
+      nodes.first
+    end
+	end
+end
+
+module EM::Xmpp
+	module XmlParser
+
+    class ForwardingParser < ::Nokogiri::XML::SAX::PushParser
+      def initialize(receiver)
+        doc = ForwardingDocument.new
+        doc.recipient = receiver
+        super doc
+      end
+    end
+
+    #XML SAX document which delegates its method to a recipient object
+    class ForwardingDocument < ::Nokogiri::XML::SAX::Document
+      attr_accessor :recipient
+      %w{xmldecl start_document end_document start_element_namespace end_element characters
+      comment warning error cdata_block}.each do |meth|
+        meth2 = "xml_#{meth}"
+        define_method(meth) do |*args|
+          recipient.send(meth2, *args)  if recipient
+        end
+      end
+    end
+
+		private
+
+    ### XML world
+    module XmlInterface
+      def xml_xmldecl(version,encoding,standalone)
+        raise NotImplementedError
+      end
+      def xml_start_document
+        raise NotImplementedError
+      end
+      def xml_end_document
+        raise NotImplementedError
+      end
+      def xml_start_element_namespace(name, attrs=[],prefix=nil,uri=nil,ns=[])
+        raise NotImplementedError
+      end
+      def xml_end_element(name)
+        raise NotImplementedError
+      end
+      def xml_characters(txt)
+        raise NotImplementedError
+      end
+      def xml_error(err)
+        raise RuntimeError, err
+      end
+      def xml_stream_closing
+        raise NotImplementedError
+      end
+      def xml_comment(comm)
+        raise NotImplementedError
+      end
+
+      def xml_warning(warn)
+        raise NotImplementedError
+      end
+
+      def xml_cdata_block(data)
+        raise NotImplementedError
+      end
+    end
+
+    module Nokogiri
+      include XmlInterface
+      def xml_xmldecl(version,encoding,standalone)
+      end
+
+      def xml_start_document
+        #XXX set namespaces and stream prefix
+        # namespace may depend on the type of connection ('jabber:client' or
+        # 'jabber:server')
+        # currently we do not set any stream's namespace, hence when builidng stanza,
+        # we must explicitely avoid writing the namespace of iq/presence/message XML nodes
+        @streamdoc = ::Nokogiri::XML::Document.new
+      end
+
+      def xml_end_document
+        @streamdoc = @stanza = @stack = @xml_parser = nil
+      end
+
+      def xml_start_element_namespace(name, attrs=[],prefix=nil,uri=nil,ns=[])
+        node = ::Nokogiri::XML::Node.new(name, @streamdoc)
+        attrs.each do |attr|
+          #attr is a Struct with members localname/prefix/uri/value
+          node[attr.localname] = attr.value
+        end
+        #XXX - if prefix is there maybe we do not want to set uri as default
+        node.default_namespace = uri if uri
+
+        ns.each do |pfx,href|
+          node.add_namespace_definition pfx, href
+        end
+
+        # puts "starting: #{name}, stack:#{@stack.size}" if $DEBUG
+        case @stack.size
+        when 0 #the streaming tag starts
+          stream_support(node)
+        when 1 #a stanza starts
+          set_current_stanza!(node)
+          stanza_start node
+        else
+          @stack.last.add_child node
+        end
+
+        @stack << node
+      end
+      def xml_end_element(name)
+        node = @stack.pop
+        #puts "ending: #{name}, stack:#{@stack.size}" if $DEBUG
+
+        case @stack.size
+        when 0 #i.e., the stream support ends
+          xml_stream_closing
+        when 1 #i.e., we've finished a stanza
+          raise RuntimeError, "should end on a stanza" unless node == @stanza
+          stanza_end node
+        else
+          #the stanza keeps growing
+        end
+      end
+
+      def xml_characters(txt)
+        @stack.last << ::Nokogiri::XML::Text.new(txt, @streamdoc)
+      end
+
+      def xml_stream_closing
+        close_xml_stream
+        close_connection
+      end
+
+      def stream_support(node)
+        @stanza = ::Nokogiri::XML::Node.new('dummy', @streamdoc)
+        node << @stanza
+
+        @streamdoc.root = node
+      end
+
+      def set_current_stanza!(node)
+        @stanza.remove
+
+        @stanza = node
+        @streamdoc.root << @stanza
+      end
+    end
+
+    module Ox
+      include XmlInterface
+      def xml_xmldecl(version,encoding,standalone)
+      end
+
+      def xml_start_document
+        #XXX set namespaces and stream prefix
+        #    namespace may depend on the type of connection ('jabber:client' or
+        #    'jabber:server')
+        #   currently we do not set any stream's namespace, hence when builidng stanza,
+        #   we must explicitely avoid writing the namespace of iq/presence/message XML nodes
+      end
+
+      def xml_end_document
+        @stanza = @stack = @xml_parser = nil
+      end
+
+      def xml_start_element_namespace(name, attrs=[],prefix=nil,uri=nil,ns=[])
+        node = ::Ox::Element.new(name)
+        node.xmlns = uri
+        attrs.each do |attr|
+          #attr is a Struct with members localname/prefix/uri/value
+          node[attr.localname] = attr.value
+        end
+
+        case @stack.size
+        when 0 #the streaming tag starts
+          stream_support(node)
+          stream_start node
+        when 1 #a stanza starts
+          set_current_stanza!(node)
+          stanza_start node
+        else
+          @stack.last << node
+        end
+
+        @stack << node
+        @text = nil
+      end
+
+      def xml_end_element(name)
+        node = @stack.pop
+        if @text
+          node << @text
+          @text = nil
+        end
+        #puts "ending: #{name}, stack:#{@stack.size}" if $DEBUG
+
+        case @stack.size
+        when 0 #i.e., the stream support ends
+          xml_stream_closing
+        when 1 #i.e., we've finished a stanza
+          raise RuntimeError, "should end on a stanza" unless node == @stanza
+          stanza_end node
+        else
+          #the stanza keeps growing
+        end
+      end
+
+      def xml_characters(txt)
+        if @text
+          @text<<txt
+        else
+          @text=txt
+        end
+      end
+
+      def xml_error(err)
+        #raise RuntimeError, err
+      end
+
+      def xml_stream_closing
+        close_xml_stream
+        close_connection
+      end
+
+      def xml_comment(comm)
+        raise NotImplementedError
+      end
+
+      def xml_warning(warn)
+        raise NotImplementedError
+      end
+
+      def xml_cdata_block(data)
+        raise NotImplementedError
+      end
+
+      ### XMPP World
+
+      def stream_support(node)
+        @stanza = ::Ox::Element.new('dummy')
+        node << @stanza
+
+        @streamdoc_root = node
+      end
+
+      def set_current_stanza!(node)
+        @stanza = node
+        @streamdoc_root.nodes[0] = @stanza
+      end
+    end
+
+ 	end
+end