sprsquish-blather 0.1

data/lib/blather/core/stream.rb

@@ -0,0 +1,179 @@
+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/sugar.rb

@@ -0,0 +1,148 @@
+module LibXML
+  module XML
+
+    class Attributes
+      def remove(name)
+        name = name.to_s
+        self.each { |a| a.remove! or break if a.name == name }
+      end
+    end #Attributes
+
+  end #XML
+end #LibXML
+
+class Class # :nodoc:
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval <<-EOS
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  def write_inheritable_attribute(key, value)
+    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+      @inheritable_attributes = {}
+    end
+    inheritable_attributes[key] = value
+  end
+
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+
+  def reset_inheritable_attributes
+    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  private
+    # Prevent this constant from being created multiple times
+    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+
+      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+      else
+        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+          memo.update(key => value.duplicable? ? value.dup : value)
+        end
+      end
+
+      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+    end
+
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end #Class
+
+class Object
+  def duplicable?; true; end
+end
+
+class NilClass #:nodoc:
+  def duplicable?; false; end
+end
+
+class FalseClass #:nodoc:
+  def duplicable?; false; end
+end
+
+class TrueClass #:nodoc:
+  def duplicable?; false; end
+end
+
+class Symbol #:nodoc:
+  def duplicable?; false; end
+end
+
+class Numeric #:nodoc:
+  def duplicable?; false; end
+end

data/lib/blather/core/xmpp_node.rb

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,85 @@
+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

data/lib/blather.rb

@@ -0,0 +1,54 @@
+$:.unshift File.dirname(__FILE__)
+
+%w[
+  rubygems
+  xml/libxml
+  eventmachine
+  digest/md5
+  logger
+
+  blather/callback
+
+  blather/core/errors
+  blather/core/jid
+  blather/core/roster
+  blather/core/roster_item
+  blather/core/sugar
+  blather/core/xmpp_node
+
+  blather/core/stanza
+  blather/core/stanza/iq
+  blather/core/stanza/iq/query
+  blather/core/stanza/iq/roster
+  blather/core/stanza/message
+  blather/core/stanza/presence
+  blather/core/stanza/presence/status
+  blather/core/stanza/presence/subscription
+
+  blather/core/stream
+  blather/core/stream/parser
+  blather/core/stream/resource
+  blather/core/stream/sasl
+  blather/core/stream/session
+  blather/core/stream/tls
+].each { |r| require r }
+
+XML::Parser.indent_tree_output = false
+
+module Blather
+  LOG = Logger.new STDOUT
+
+  def run(jid, password, client, host = nil, port = 5222)
+    EM.run { Stream.start client, JID.new(jid), password, host, port }
+  end
+  module_function :run
+
+  MAJOR = 0
+  MINOR = 1
+  VERSION = [MAJOR, MINOR]*'.'
+
+  def version
+    VERSION
+  end
+  module_function :version
+end

data/spec/blather/core/jid_spec.rb

@@ -0,0 +1,78 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::JID' do
+  it 'does nothing if creaded from JID' do
+    jid = JID.new 'n@d/r'
+    JID.new(jid).object_id.must_equal jid.object_id
+  end
+
+  it 'creates a new JID from (n,d,r)' do
+    jid = JID.new('n', 'd', 'r')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+    jid.resource.must_equal 'r'
+  end
+
+  it 'creates a new JID from (n,d)' do
+    jid = JID.new('n', 'd')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+  end
+
+  it 'creates a new JID from (n@d)' do
+    jid = JID.new('n@d')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+  end
+
+  it 'creates a new JID from (n@d/r)' do
+    jid = JID.new('n@d/r')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+    jid.resource.must_equal 'r'
+  end
+
+  it 'requires at least a node' do
+    proc { JID.new }.must_raise ArgumentError
+  end
+
+  it 'ensures length of node is no more than 1023 characters' do
+    proc { JID.new('n'*1024) }.must_raise Blather::ArgumentError
+  end
+
+  it 'ensures length of domain is no more than 1023 characters' do
+    proc { JID.new('n', 'd'*1024) }.must_raise Blather::ArgumentError
+  end
+
+  it 'ensures length of resource is no more than 1023 characters' do
+    proc { JID.new('n', 'd', 'r'*1024) }.must_raise Blather::ArgumentError
+  end
+
+  it 'compares JIDs' do
+    (JID.new('a@b/c') <=> JID.new('d@e/f')).must_equal -1
+    (JID.new('a@b/c') <=> JID.new('a@b/c')).must_equal 0
+    (JID.new('d@e/f') <=> JID.new('a@b/c')).must_equal 1
+  end
+
+  it 'checks for equality' do
+    (JID.new('n@d/r') == JID.new('n@d/r')).must_equal true
+  end
+
+  it 'will strip' do
+    jid = JID.new('n@d/r')
+    jid.stripped.must_equal JID.new('n@d')
+    jid.must_equal JID.new('n@d/r')
+  end
+
+  it 'will strip itself' do
+    jid = JID.new('n@d/r')
+    jid.strip!
+    jid.must_equal JID.new('n@d')
+  end
+
+  it 'has a string representation' do
+    JID.new('n@d/r').to_s.must_equal 'n@d/r'
+    JID.new('n', 'd', 'r').to_s.must_equal 'n@d/r'
+    JID.new('n', 'd').to_s.must_equal 'n@d'
+  end
+end