sprsquish-blather 0.1 → 0.2.3

data/lib/blather/core/stanza.rb

@@ -1,90 +0,0 @@
-module Blather
-  class Stanza < XMPPNode
-    @@registered_callbacks = []
-
-    def self.registered_callbacks
-      @@registered_callbacks
-    end
-
-    class_inheritable_array :callback_heirarchy
-
-    def self.register(callback_type, name = nil, xmlns = nil)
-      @@registered_callbacks << callback_type
-
-      self.callback_heirarchy ||= []
-      self.callback_heirarchy.unshift callback_type
-
-      name = name || self.name || callback_type
-      super name, xmlns
-    end
-
-    def self.next_id
-      @@last_id ||= 0
-      @@last_id += 1
-      'blather%04x' % @@last_id
-    end
-
-    def self.import(node)
-      self.new(node.element_name).inherit(node)
-    end
-
-    def self.new(elem_name = nil)
-      elem = super
-      elem.id = next_id
-      XML::Document.new.root = elem
-      elem
-    end
-
-    def error?
-      self.type == :error
-    end
-
-    def reply
-      elem = self.copy(true)
-      elem.to, elem.from = self.from, self.to
-      elem
-    end
-
-    def reply!
-      self.to, self.from = self.from, self.to
-      self
-    end
-
-    def id=(id)
-      attributes.remove :id
-      self['id'] = id if id
-    end
-
-    def id
-      self['id']
-    end
-
-    def to=(to)
-      attributes.remove :to
-      self['to'] = to.to_s if to
-    end
-
-    def to
-      JID.new(self['to']) if self['to']
-    end
-
-    def from=(from)
-      attributes.remove :from
-      self['from'] = from.to_s if from
-    end
-
-    def from
-      JID.new(self['from']) if self['from']
-    end
-
-    def type=(type)
-      attributes.remove :type
-      self['type'] = type.to_s
-    end
-
-    def type
-      self['type'].to_sym if self['type']
-    end
-
-  end
-end

data/lib/blather/core/stream.rb

@@ -1,179 +0,0 @@
-module Blather
-
-  module Stream
-
-    # Connect to the server
-    def self.start(client, jid, pass, host = nil, port = 5222)
-      jid = JID.new jid
-      host ||= jid.domain
-
-      EM.connect host, port, self, client, jid, pass
-    end
-
-    def initialize(client, jid, pass)
-      super()
-
-      @client = client
-
-      self.jid = jid
-      @pass = pass
-
-      @to = @jid.domain
-      @id = nil
-      @lang = 'en'
-      @version = '1.0'
-      @namespace = 'jabber:client'
-
-      @parser = Parser.new self
-    end
-
-    def connection_completed
-#      @keepalive = EM::Timer.new(60) { send_data ' ' }
-      @state = :stopped
-      dispatch
-    end
-
-    def receive_data(data)
-      @parser.parse data
-
-    rescue => e
-      @client.respond_to?(:rescue) ? @client.rescue(e) : raise(e)
-    end
-
-    def unbind
-#      @keepalive.cancel
-      @state == :stopped
-    end
-
-    def receive(node)
-      LOG.debug "\n"+('-'*30)+"\n"
-      LOG.debug "RECEIVING (#{node.element_name}) #{node}"
-      @node = node
-
-      case @node.element_name
-      when 'stream:stream'
-        @state = :ready if @state == :stopped
-
-      when 'stream:end'
-        @state = :stopped
-
-      when 'stream:features'
-        @features = @node.children
-        @state = :features
-        dispatch
-
-      when 'stream:error'
-        raise StreamError.new(@node)
-
-      else
-        dispatch
-
-      end
-    end
-
-    def send(stanza)
-      #TODO Queue if not ready
-      LOG.debug "SENDING: (#{caller[1]}) #{stanza}"
-      send_data stanza.to_s
-    end
-
-    def stopped?
-      @state == :stopped
-    end
-
-    def ready?
-      @state == :ready
-    end
-
-    def jid=(new_jid)
-      LOG.debug "NEW JID: #{new_jid}"
-      new_jid = JID.new new_jid
-      @client.jid = new_jid
-      @jid = new_jid
-    end
-
-  private
-    def dispatch
-      __send__ @state
-    end
-
-    def start
-      send <<-STREAM
-        <stream:stream
-          to='#{@to}'
-          xmlns='#{@namespace}'
-          xmlns:stream='http://etherx.jabber.org/streams'
-          version='#{@version}'
-          xml:lang='#{@lang}'
-        >
-      STREAM
-    end
-
-    def stop
-      send '</stream:stream>'
-    end
-
-    def stopped
-      start
-    end
-
-    def ready
-      @client.call @node.to_stanza
-    end
-
-    def features
-      feature = @features.first
-      LOG.debug "FEATURE: #{feature}"
-      @state = case feature ? feature['xmlns'] : nil
-      when 'urn:ietf:params:xml:ns:xmpp-tls'      then :establish_tls
-      when 'urn:ietf:params:xml:ns:xmpp-sasl'     then :authenticate_sasl
-      when 'urn:ietf:params:xml:ns:xmpp-bind'     then :bind_resource
-      when 'urn:ietf:params:xml:ns:xmpp-session'  then :establish_session
-      else :ready
-      end
-
-      dispatch unless ready?
-    end
-
-    def establish_tls
-      unless @tls
-        @tls = TLS.new self
-        @tls.success { LOG.debug "TLS: SUCCESS"; @tls = nil; start }
-        @tls.failure { LOG.debug "TLS: FAILURE"; stop }
-        @node = @features.shift
-      end
-      @tls.receive @node
-    end
-
-    def authenticate_sasl
-      unless @sasl
-        @sasl = SASL.new(self, @jid, @pass)
-        @sasl.success { LOG.debug "SASL SUCCESS"; @sasl = nil; start }
-        @sasl.failure { LOG.debug "SASL FAIL"; stop }
-        @node = @features.shift
-      end
-      @sasl.receive @node
-    end
-
-    def bind_resource
-      unless @resource
-        @resource = Resource.new self, @jid
-        @resource.success { |jid| LOG.debug "RESOURCE: SUCCESS"; @resource = nil; self.jid = jid; @state = :features; dispatch }
-        @resource.failure { LOG.debug "RESOURCE: FAILURE"; stop }
-        @node = @features.shift
-      end
-      @resource.receive @node
-    end
-
-    def establish_session
-      unless @session
-        @session = Session.new self, @to
-        @session.success { LOG.debug "SESSION: SUCCESS"; @session = nil; @client.stream_started(self); @state = :features; dispatch }
-        @session.failure { LOG.debug "SESSION: FAILURE"; stop }
-        @node = @features.shift
-      end
-      @session.receive @node
-    end
-  end
-
-end

data/lib/blather/core/xmpp_node.rb

@@ -1,95 +0,0 @@
-module Blather
-
-  class XMPPNode < XML::Node
-    @@registrations = {}
-
-    alias_method :element_name, :name
-
-    class_inheritable_accessor  :xmlns,
-                                :name
-
-    def self.new(name = nil, content = nil)
-      name ||= self.name
-
-      args = []
-      args << name.to_s if name
-      args << content if content
-
-      elem = super *args
-      elem.xmlns = xmlns
-      elem
-    end
-
-    def self.register(name, xmlns = nil)
-      self.name = name.to_s
-      self.xmlns = xmlns
-      @@registrations[[name, xmlns]] = self
-    end
-
-    def self.class_from_registration(name, xmlns)
-      name = name.to_s
-      @@registrations[[name, xmlns]] || @@registrations[[name, nil]]
-    end
-
-    def self.import(node)
-      klass = class_from_registration(node.element_name, node.xmlns)
-      if klass && klass != self
-        klass.import(node)
-      else
-        new(node.element_name).inherit(node)
-      end
-    end
-
-    def to_stanza
-      self.class.import self
-    end
-
-    def xmlns=(ns)
-      attributes.remove :xmlns
-      self['xmlns'] = ns if ns
-    end
-
-    def xmlns
-      self['xmlns']
-    end
-
-    def remove_child(name, ns = nil)
-      name = name.to_s
-      self.each { |n| n.remove! if n.element_name == name && (!ns || n.xmlns == ns) }
-    end
-
-    def remove_children(name)
-      name = name.to_s
-      self.find(name).each { |n| n.remove! }
-    end
-
-    def content_from(name)
-      name = name.to_s
-      (child = self.detect { |n| n.element_name == name }) ? child.content : nil
-    end
-
-    def copy(deep = true)
-      self.class.new(self.element_name).inherit(self)
-    end
-
-    def inherit(stanza)
-      inherit_attrs stanza.attributes
-      stanza.children.each { |c| self << c.copy(true) }
-      self
-    end
-
-    def inherit_attrs(attrs)
-      attrs.each  { |a| self[a.name] = a.value }
-      self
-    end
-
-    def to_s
-      super.gsub(">\n<", '><')
-    end
-
-    def find(what, nslist = nil)
-      (self.doc ? super(what, nslist) : select { |i| i.element_name == what})
-    end
-  end #XMPPNode
-
-end

data/lib/blather/extensions/last_activity.rb

@@ -1,57 +0,0 @@
-module Blather
-  module Extensions
-
-    module LastActivity
-      def self.included(base)
-        base.class_eval do
-          @@last_activity = Time.now
-
-          alias_method :send_data_without_activity, :send_data
-          def send_data(data)
-            @@last_activity = Time.now
-            send_data_without_activity data
-          end
-        end
-      end
-
-      def last_activity
-        (Time.now - @@last_activity).to_i
-      end
-
-      def receive_last_activity(stanza)
-        send_data stanza.reply!(last_activity) if stanza.type == 'get'
-      end
-    end #LastActivity
-
-    class LastActivityStanza < Query
-      register :last_activity, nil, 'jabber:iq:last'
-
-      def self.new(type = :get, seconds = nil)
-        elem = super type
-        elem.seconds = seconds
-        elem
-      end
-
-      def seconds=(seconds)
-        query.attributes.remove :seconds
-        query['seconds'] = seconds.to_i.to_s if seconds
-      end
-
-      def seconds
-        (query['seconds'] || 0).to_i
-      end
-
-      def reply(seconds)
-        elem = super()
-        elem.last_activity = seconds
-      end
-
-      def reply!(seconds)
-        self.last_activity = seconds
-        super()
-      end
-    end #LastActivityStanza
-  end
-end
-
-Blather::Client.__send__ :include, Blather::Extensions::LastActivity

data/lib/blather/extensions/version.rb

@@ -1,85 +0,0 @@
-module Blather
-  module Extensions
-
-    module Version
-      def self.included(base)
-        base.class_eval do
-          @@version = {}
-
-          def self.version(name, ver, os = nil)
-            @@version = {:name => name, :version => ver, :os => os}
-          end
-
-          add_callback(:iq, 100) do |c, s|
-            if s.detect { |n| n['xmlns'] == 'jabber:iq:version' }
-              ver = VersionStanza.new('result', c.version)
-              ver.id = s.id
-              ver.from = c.jid
-              ver.to = s.from
-              c.send_data ver
-            end
-          end
-        end
-      end
-
-      def version
-        @@version
-      end
-    end #Version
-
-    class VersionStanza < Iq
-      def self.new(type = 'result', ver = {})
-        elem = super(type)
-
-        query = XML::Node.new('query')
-        query.xmlns = 'jabber:iq:version'
-        elem << query
-
-        elem.name = ver[:name] if ver[:name]
-        elem.version = ver[:version] if ver[:version]
-        elem.os = ver[:os] if ver[:os]
-
-        elem
-      end
-
-      def query
-        @query ||= self.detect { |n| n.name == 'query' }
-      end
-
-      def name=(name)
-        query.each { |n| n.remove! or break if n.name == 'name' }
-        query << XML::Node.new('name', name)
-      end
-
-      def name
-        if name = query.detect { |n| n.name == 'name' }
-          name.content
-        end
-      end
-
-      def version=(version)
-        query.each { |n| n.remove! or break if n.name == 'version' }
-        query << XML::Node.new('version', version)
-      end
-
-      def version
-        if version = query.detect { |n| n.version == 'version' }
-          version.content
-        end
-      end
-
-      def os=(os)
-        query.each { |n| n.remove! or break if n.name == 'os' }
-        query << XML::Node.new('os', os)
-      end
-
-      def os
-        if os = query.detect { |n| n.os == 'os' }
-          os.content
-        end
-      end
-    end #VersionStanza
-  end
-end
-
-Blather::Client.__send__ :include, Blather::Extensions::Version