blather 0.2.3 → 0.3.0

data/lib/blather/stanza.rb

@@ -93,9 +93,8 @@ module Blather
     # Transform the stanza into a stanza error
     # <tt>err_name_or_class</tt> can be the name of the error or the error class to use
     # <tt>type</tt>, <tt>text</tt>, <tt>extras</tt> are the same as for StanzaError#new
-    def as_error(err_name_or_class, type, text = nil, extras = [])
-      klass = (err_name_or_class.is_a?(Class) ? err_name_or_class : StanzaError.class_from_registration(err_name_or_class))
-      klass.new self, type, text, extras
+    def as_error(name, type, text = nil, extras = [])
+      StanzaError.new self, name, type, text, extras
     end
   end
 end

data/lib/blather/stanza/{iq/disco.rb → disco.rb}

@@ -1,11 +1,9 @@
 module Blather
 class Stanza
-class Iq
 
-  class Disco < Query
+  class Disco < Iq::Query
     attribute_accessor :node, :to_sym => false
   end
 
-end #Iq
 end #Stanza
 end #Blather

data/lib/blather/stanza/{iq/discos → disco}/disco_info.rb

@@ -1,6 +1,5 @@
 module Blather
 class Stanza
-class Iq
 
   ##
   # DiscoInfo object ()
@@ -8,9 +7,11 @@ class Iq
   class DiscoInfo < Disco
     register :disco_info, nil, 'http://jabber.org/protocol/disco#info'
 
-    def initialize(type = nil, identities = [], features = [], node = nil)
+    def initialize(type = nil, node = nil, identities = [], features = [])
       super type
 
+      self.node = node
+
       [identities].flatten.each do |id|
         query << (id.is_a?(Identity) ? id : Identity.new(id[:name], id[:type], id[:category]))
       end
@@ -18,8 +19,6 @@ class Iq
       [features].flatten.each do |feature|
         query << (feature.is_a?(Feature) ? feature : Feature.new(feature))
       end
-
-      self.node = node
     end
 
     ##
@@ -81,6 +80,5 @@ class Iq
     end
   end
 
-end #Iq
 end #Stanza
 end #Blather

data/lib/blather/stanza/{iq/discos → disco}/disco_items.rb

@@ -1,6 +1,5 @@
 module Blather
 class Stanza
-class Iq
 
   class DiscoItems < Disco
     register :disco_items, nil, 'http://jabber.org/protocol/disco#items'
@@ -56,6 +55,5 @@ class Iq
     end
   end
 
-end #Iq
 end #Stanza
 end #Blather

data/lib/blather/stanza/iq/query.rb

@@ -8,7 +8,7 @@ class Iq
     ##
     # Ensure the namespace is set to the query node
     def initialize(type = nil)
-      super()
+      super
       query.namespace = self.class.ns
     end
 

data/lib/blather/stanza/iq/roster.rb

@@ -27,8 +27,8 @@ class Iq
     ##
     # Roster items
     def items
-      items = query.find('item')
-      items = query.find('query_ns:item', :query_ns => self.class.ns) if items.empty?
+      items = query.find('//item', self.class.ns)
+      items = query.find('//query_ns:item', :query_ns => self.class.ns) if items.empty?
       items.map { |i| RosterItem.new(i) }
     end
 

data/lib/blather/stanza/pubsub/subscriber.rb

@@ -0,0 +1,64 @@
+module Blather
+class Stanza
+class PubSub
+
+  module Subscriber
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module ClassMethods
+      def subscribe(host, node, jid)
+        stanza = self.new(:set, host)
+        subscription = XMPPNode.new 'subscription'
+        subscription.attributes[:node] = node
+        subscription.attributes[:jid] = JID.new(jid).stripped
+        stanza.pubsub << subscription
+        stanza
+      end
+
+      def unsubscribe(host, node, jid, subid = nil)
+        stanza = self.new(:set, host)
+        unsubscription = XMPPNode.new 'unsubscribe'
+        unsubscription.attributes[:node] = node
+        unsubscription.attributes[:jid] = JID.new(jid).stripped
+        unsubscription.attributes[:subid] = subid
+        stanza.pubsub << unsubscription
+        stanza
+      end
+    end
+
+    module InstanceMethods
+      def subscription
+        if sub = subscription?
+          { :node         => sub.attributes[:node],
+            :jid          => JID.new(sub.attributes[:jid]),
+            :subid        => sub.attributes[:subid],
+            :subscription => sub.attributes[:subscription] }
+        end
+      end
+
+      def subscription?
+        find_first('//pubsub_ns:pubsub/pubsub_ns:subscription', :pubsub_ns => self.ns)
+      end
+
+      def unsubscribe
+        if sub = unsubscribe?
+          { :node => sub.attributes[:node],
+            :jid  => JID.new(sub.attributes[:jid]) }
+        end
+      end
+
+      def unsubscribe?
+        find_first('//pubsub_ns:pubsub/pubsub_ns:unsubscribe', :pubsub_ns => self.ns)
+      end
+    end
+
+  end #Subscriber
+
+end #PubSub
+end #Stanza
+end #Blather

data/lib/blather/stream.rb

@@ -97,23 +97,23 @@ module Blather
       LOG.debug "RECEIVING (#{node.element_name}) #{node}"
       @node = node
 
+      if @node.find_first('//stream:error', :stream => 'http://etherx.jabber.org/streams')
+        handle_stream_error
+        return
+      end
+
       case @node.element_name
-      when 'stream:stream'
+      when 'stream'
         @state = :ready if @state == :stopped
 
       when 'stream:end'
         stop
 
-      when 'stream:features'
+      when 'features'
         @features = @node.children
         @state = :features
         dispatch
 
-      when 'stream:error'
-        @error = StreamError.import @node
-        stop
-        @state = :error
-
       else
         dispatch
 
@@ -165,6 +165,12 @@ module Blather
       @client.call @node.to_stanza
     end
 
+    def handle_stream_error
+      @error = StreamError.import @node
+      stop
+      @state = :error
+    end
+
     ##
     # Called when @state == :features
     #   Runs through the list of features starting each one in turn

data/lib/blather/stream/component.rb

@@ -11,7 +11,7 @@ class Stream
         super
       end
 
-      if node.element_name == 'stream:stream'
+      if node.namespaces.find_by_href('http://etherx.jabber.org/streams') && node.find_first('/stream:stream[not(stream:error)]')
         send("<handshake>#{Digest::SHA1.hexdigest(@node['id']+@pass)}</handshake>")
       end
     end

data/lib/blather/stream/parser.rb

@@ -19,21 +19,28 @@ class Stream # :nodoc:
 
     def receive_data(string)
       LOG.debug "PARSING: (#{string})" if @@debug
+      @stream_error = string =~ /stream:error/
       @parser.receive string
     end
 
     def on_start_element_ns(elem, attrs, prefix, uri, namespaces)
       LOG.debug "START ELEM: (#{{:elem => elem, :attrs => attrs, :prefix => prefix, :uri => uri, :ns => namespaces}.inspect})" if @@debug
-      elem = "#{"#{prefix}:" if prefix}#{elem}"
+
       e = XMPPNode.new elem
-      XML::Namespace.new(e, prefix, uri)
       attrs.each { |k,v| e.attributes[k] = v if k }
 
-      if elem == 'stream:stream'
+      if @current && (ns = @current.namespaces.find_by_href(uri))
+        e.namespace = ns
+      else
+        e.namespace = {prefix => uri}
+      end
+
+      if elem == 'stream' && !@stream_error
+        XML::Document.new.root = e
         @receiver.receive e
 
       elsif !@receiver.stopped?
-        @current << e if @current
+        @current << e  if @current
         @current = e
 
       end

data/lib/blather/stream/resource.rb

@@ -32,7 +32,7 @@ class Stream # :nodoc:
       LOG.debug "RESOURE NODE #{@node}"
       # ensure this is a response to our original request
       if @id == @node['id']
-        @jid = JID.new @node.find_first('bind/jid').content
+        @jid = JID.new @node.find_first('//bind_ns:bind/bind_ns:jid', :bind_ns => 'urn:ietf:params:xml:ns:xmpp-bind').content
         success @jid
       end
     end

data/lib/blather/stream/sasl.rb

@@ -18,19 +18,25 @@ class Stream # :nodoc:
     end
 
     def set_mechanism
-      mod = case (mechanism = @mechanisms[@mechanism_idx].content)
-      when 'DIGEST-MD5' then DigestMD5
-      when 'PLAIN'      then Plain
-      when 'ANONYMOUS'  then Anonymous
+      mod = if @jid.node == '' && @mechanisms.find { |m| m.content == 'ANONYMOUS' }
+        Anonymous
+      else
+        case (mechanism = @mechanisms[@mechanism_idx].content)
+        when 'DIGEST-MD5' then DigestMD5
+        when 'PLAIN'      then Plain
+        when 'ANONYMOUS'  then Anonymous
+        end
+      end
+
+      if mod
+        extend mod
+        true
       else
         # Send a failure node and kill the stream
         @stream.send "<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><invalid-mechanism/></failure>"
         @failure.call UnknownMechanism.new("Unknown SASL mechanism (#{mechanism})")
-        return false
+        false
       end
-
-      extend mod
-      true
     end
 
     ##
@@ -164,7 +170,7 @@ class Stream # :nodoc:
 
     module Anonymous # :nodoc:
       def authenticate
-        @stream.send auth_node('ANONYMOUS', b64(@jid.node))
+        @stream.send auth_node('ANONYMOUS')
       end
     end #Anonymous
   end #SASL

data/lib/blather/xmpp_node.rb

@@ -126,10 +126,16 @@ module Blather
       self.class.import self
     end
 
-    def namespace=(ns)
-      if ns
-        ns = {nil => ns} unless ns.is_a?(Hash)
-        ns.each { |p,n| XML::Namespace.new self, p, n }
+    def namespace=(namespaces)
+      case namespaces
+      when XML::Namespace
+        self.namespaces.namespace = namespaces
+      when String
+        self.namespaces.namespace = XML::Namespace.new(self, nil, namespaces)
+      when Hash
+        namespaces.each do |p, n|
+          self.namespaces.namespace = XML::Namespace.new(self, p, n)
+        end
       end
     end
 

data/spec/blather/client/client_spec.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::Client' do
+end

data/spec/blather/client/dsl_spec.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::DSL' do
+end

data/spec/blather/errors/sasl_error_spec.rb

@@ -15,23 +15,6 @@ describe 'Blather::SASLError' do
     e.must_be_kind_of SASLError
   end
 
-  it 'knows what class to instantiate' do
-    e = SASLError.import sasl_error_node
-    e.must_be_instance_of SASLError::Aborted
-  end
-
-  describe 'when instantiated' do
-    before do
-      @err_name = 'mechanism-too-weak'
-      @err = SASLError.import sasl_error_node(@err_name)
-    end
-
-    it 'provides a err_name attribute' do
-      @err.must_respond_to :err_name
-      @err.err_name.must_equal @err_name
-    end
-  end
-
   describe 'each XMPP SASL error type' do
     %w[ aborted
         incorrect-encoding
@@ -41,15 +24,9 @@ describe 'Blather::SASLError' do
         not-authorized
         temporary-auth-failure
     ].each do |error_type|
-      it "provides a class for #{error_type}" do
-        e = SASLError.import sasl_error_node(error_type)
-        klass = error_type.gsub(/^\w/) { |v| v.upcase }.gsub(/\-(\w)/) { |v| v.delete('-').upcase }
-        e.must_be_instance_of eval("SASLError::#{klass}")
-      end
-
-      it "registers #{error_type} in the handler heirarchy" do
+      it "handles the name for #{error_type}" do
         e = SASLError.import sasl_error_node(error_type)
-        e.handler_heirarchy.must_equal ["sasl_#{error_type.gsub('-','_').gsub('_error','')}_error".to_sym, :sasl_error, :error]
+        e.name.must_equal error_type.gsub('-','_').to_sym
       end
     end
   end

data/spec/blather/errors/stanza_error_spec.rb

@@ -34,19 +34,14 @@ describe 'Blather::StanzaError' do
     e.must_be_kind_of StanzaError
   end
 
-  it 'knows what class to instantiate' do
-    e = StanzaError.import stanza_error_node
-    e.must_be_instance_of StanzaError::InternalServerError
-  end
-
   describe 'valid types' do
     before { @original = Stanza::Message.new 'error@jabber.local', 'test message', :error }
 
     it 'ensures type is one of Stanza::Message::VALID_TYPES' do
-      lambda { StanzaError.new @original, :invalid_type_name }.must_raise(Blather::ArgumentError)
+      lambda { StanzaError.new @original, :gone, :invalid_type_name }.must_raise(Blather::ArgumentError)
 
       StanzaError::VALID_TYPES.each do |valid_type|
-        msg = StanzaError.new @original, valid_type
+        msg = StanzaError.new @original, :gone, valid_type
         msg.type.must_equal valid_type
       end
     end
@@ -65,9 +60,9 @@ describe 'Blather::StanzaError' do
       @err.type.must_equal @type.to_sym
     end
 
-    it 'provides a err_name attribute' do
-      @err.must_respond_to :err_name
-      @err.err_name.must_equal @err_name
+    it 'provides a name attribute' do
+      @err.must_respond_to :name
+      @err.name.must_equal @err_name.gsub('-','_').to_sym
     end
 
     it 'provides a text attribute' do
@@ -131,15 +126,9 @@ describe 'Blather::StanzaError' do
         undefined-condition
         unexpected-request
       ].each do |error_type|
-        it "provides a class for #{error_type}" do
-          e = StanzaError.import stanza_error_node(:cancel, error_type)
-          klass = error_type.gsub(/^\w/) { |v| v.upcase }.gsub(/\-(\w)/) { |v| v.delete('-').upcase }
-          e.must_be_instance_of eval("StanzaError::#{klass}")
-        end
-
-        it "registers #{error_type} in the handler heirarchy" do
+        it "handles the name for #{error_type}" do
           e = StanzaError.import stanza_error_node(:cancel, error_type)
-          e.handler_heirarchy.must_equal ["stanza_#{error_type.gsub('-','_').gsub('_error','')}_error".to_sym, :stanza_error, :error]
+          e.name.must_equal error_type.gsub('-','_').to_sym
         end
       end
   end

data/spec/blather/errors/stream_error_spec.rb

@@ -29,11 +29,6 @@ describe 'Blather::StreamError' do
     e = StreamError.import stream_error_node
     e.must_be_kind_of StreamError
   end
-
-  it 'knows what class to instantiate' do
-    e = StreamError.import stream_error_node
-    e.must_be_instance_of StreamError::InternalServerError
-  end
 end
 
 describe 'Blather::StreamError when instantiated' do
@@ -44,8 +39,8 @@ describe 'Blather::StreamError when instantiated' do
   end
 
   it 'provides a err_name attribute' do
-    @err.must_respond_to :err_name
-    @err.err_name.must_equal @err_name
+    @err.must_respond_to :name
+    @err.name.must_equal @err_name.gsub('-','_').to_sym
   end
 
   it 'provides a text attribute' do
@@ -100,15 +95,9 @@ describe 'Each XMPP stream error type' do
       unsupported-version
       xml-not-well-formed
     ].each do |error_type|
-      it "provides a class for #{error_type}" do
-        e = StreamError.import stream_error_node(error_type)
-        klass = error_type.gsub(/^\w/) { |v| v.upcase }.gsub(/\-(\w)/) { |v| v.delete('-').upcase }
-        e.must_be_instance_of eval("StreamError::#{klass}")
-      end
-
-      it "registers #{error_type} in the handler heirarchy" do
+      it "handles the name for #{error_type}" do
         e = StreamError.import stream_error_node(error_type)
-        e.handler_heirarchy.must_equal ["stream_#{error_type.gsub('-','_').gsub('_error','')}_error".to_sym, :stream_error, :error]
+        e.name.must_equal error_type.gsub('-','_').to_sym
       end
     end
 end