blather 0.1

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

@@ -0,0 +1,42 @@
+module Blather
+class Stanza
+class Iq
+
+  class Query < Iq
+    register :query, :query
+
+    def self.new(type)
+      elem = super
+      elem.query.xmlns = self.xmlns
+      elem
+    end
+
+    def inherit(node)
+      query.remove!
+      @query = nil
+      super
+    end
+
+    def query
+      @query ||= if q = find_first('query')
+        q
+      else
+        self << q = XMPPNode.new('query')
+        q
+      end
+    end
+
+    def reply
+      elem = super
+      elem.type = :result
+    end
+
+    def reply!
+      self.type = :result
+      super
+    end
+  end #Query
+
+end #Iq
+end #Stanza
+end

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

@@ -0,0 +1,96 @@
+module Blather
+class Stanza
+class Iq
+
+  class Roster < Query
+    register :roster, nil, 'jabber:iq:roster'
+
+    def self.new(type, item = nil)
+      elem = super(type)
+      elem.query << item
+      elem
+    end
+
+    def inherit(node)
+      items.each { |i| i.remove! }
+      @items = nil
+      super
+      items.each { |i| query << RosterItem.new(i); i.remove! }
+      @items = nil
+      self
+    end
+
+    def items
+      @items ||= query.find('item')#.map { |g| RosterItem.new g }
+    end
+
+    class RosterItem < XMPPNode
+      def self.new(jid = nil, name = nil, subscription = nil, ask = nil)
+        elem = super('item')
+        if jid.is_a?(XML::Node)
+          elem.inherit jid
+        else
+          elem.jid = jid
+          elem.name = name
+          elem.subscription = subscription
+          elem.ask = ask
+        end
+        elem
+      end
+
+      def jid
+        (j = self['jid']) ? JID.new(j) : nil
+      end
+
+      def jid=(jid)
+        attributes.remove :jid
+        self['jid'] = jid.to_s if jid
+      end
+
+      def name
+        self['name']
+      end
+
+      def name=(name)
+        attributes.remove :name
+        self['name'] = name if name
+      end
+
+      def subscription
+        self['subscription'].to_sym if self['subscription']
+      end
+
+      def subscription=(subscription)
+        attributes.remove :subscription
+        self['subscription'] = subscription.to_s if subscription
+      end
+
+      def ask
+        self['ask'].to_sym if self['ask']
+      end
+
+      def ask=(ask)
+        attributes.remove :ask
+        self['ask'] = ask if ask
+      end
+
+      def groups
+        @groups ||= find('group').map { |g| g.content }
+      end
+
+      def groups=(grps)
+        find('group').each { |g| g.remove! }
+        @groups = nil
+
+        grps.uniq.each { |g| add_node XML::Node.new('group', g.to_s) } if grps
+      end
+
+      def to_stanza
+        Roster.new(:set, self)
+      end
+    end #RosterItem
+  end #Roster
+
+end #Iq
+end #Stanza
+end

data/lib/blather/core/stanza/message.rb

@@ -0,0 +1,55 @@
+module Blather
+class Stanza
+
+  ##
+  # Base Message stanza
+  class Message < Stanza
+    VALID_TYPES = [:chat, :error, :groupchat, :headline, :normal]
+
+    register :message
+
+    def self.new(to = nil, type = nil, body = nil)
+      elem = super()
+      elem.to = to
+      elem.type = type
+      elem.body = body
+      elem
+    end
+
+    ##
+    # Ensures type is :chat, :error, :groupchat, :headline or :normal
+    def type=(type)
+      raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}" if type && !VALID_TYPES.include?(type.to_sym)
+      super
+    end
+
+    def body=(body)
+      remove_child :body
+      self << XMPPNode.new('body', body) if body
+    end
+
+    def body
+      content_from :body
+    end
+
+    def subject=(subject)
+      remove_child :subject
+      self << XMPPNode.new('subject', subject) if subject
+    end
+
+    def subject
+      content_from :subject
+    end
+
+    def thread=(thread)
+      remove_child :thread
+      self << XMPPNode.new('body', body) if body
+    end
+
+    def thread
+      content_from :thread
+    end
+  end
+
+end #Stanza
+end

data/lib/blather/core/stanza/presence.rb

@@ -0,0 +1,35 @@
+module Blather
+class Stanza
+
+  ##
+  # Base Presence stanza
+  class Presence < Stanza
+    VALID_TYPES = [:unavailable, :subscribe, :subscribed, :unsubscribe, :unsubscribed, :probe, :error]
+
+    register :presence
+
+    ##
+    # Creates a class based on the presence type
+    # either a Status or Subscription object is created based
+    # on the type attribute.
+    # If neither is found it instantiates a Presence object
+    def self.import(node)
+      klass = case node['type']
+      when nil, 'unavailable' then Status
+      when /subscribe/        then Subscription
+      else self
+      end
+      klass.new.inherit(node)
+    end
+
+    ##
+    # Ensures type is one of :unavailable, :subscribe, :subscribed, :unsubscribe, :unsubscribed, :probe or :error
+    def type=(type)
+      raise ArgumentError, "Invalid Type (#{type}), use: #{VALID_TYPES*' '}" if type && !VALID_TYPES.include?(type.to_sym)
+      super
+    end
+
+  end
+
+end #Stanza
+end

data/lib/blather/core/stanza/presence/status.rb

@@ -0,0 +1,77 @@
+module Blather
+class Stanza
+class Presence
+
+  class Status < Presence
+    VALID_STATES = [:away, :chat, :dnd, :xa]
+
+    include Comparable
+
+    register :status
+
+    def self.new(state = nil, message = nil)
+      elem = super()
+      elem.state = state
+      elem.message = message
+      elem
+    end
+
+    ##
+    # Ensures type is nil or :unavailable
+    def type=(type)
+      raise ArgumentError, "Invalid type (#{type}). Must be nil or unavailable" if type && type.to_sym != :unavailable
+      super
+    end
+
+    ##
+    # Ensure state is one of :away, :chat, :dnd, :xa or nil
+    def state=(state)
+      state = state.to_sym if state
+      state = nil if state == :available
+      raise ArgumentError, "Invalid Status (#{state}), use: #{VALID_STATES*' '}" if state && !VALID_STATES.include?(state)
+
+      remove_child :show
+      self << XMPPNode.new('show', state) if state
+    end
+
+    ##
+    # return:: :available if state is nil
+    def state
+      (type || content_from(:show) || :available).to_sym
+    end
+
+    ##
+    # Ensure priority is between -128 and 127
+    def priority=(priority)
+      raise ArgumentError, 'Priority must be between -128 and +127' if priority && !(-128..127).include?(priority.to_i)
+
+      remove_child :priority
+      self << XMPPNode.new('priority', priority) if priority
+    end
+
+    def priority
+      @priority ||= content_from(:priority).to_i
+    end
+
+    def message=(msg)
+      remove_child :status
+      self << XMPPNode.new('status', msg) if msg
+    end
+
+    def message
+      content_from :status
+    end
+
+    ##
+    # Compare status based on priority
+    # raises an error if the JIDs aren't the same
+    def <=>(o)
+      raise "Cannot compare status from different JIDs: #{[self.from, o.from].inspect}" unless self.from.stripped == o.from.stripped
+      self.priority <=> o.priority
+    end
+
+  end #Status
+
+end #Presence
+end #Stanza
+end #Blather

data/lib/blather/core/stanza/presence/subscription.rb

@@ -0,0 +1,73 @@
+module Blather
+class Stanza
+class Presence
+
+  class Subscription < Presence
+    register :subscription
+
+    def self.new(to = nil, type = nil)
+      elem = super()
+      elem.to = to
+      elem.type = type
+      elem
+    end
+
+    def inherit(node)
+      inherit_attrs node.attributes
+      self
+    end
+
+    def to=(to)
+      super JID.new(to).stripped
+    end
+
+    ##
+    # Create an approve stanza
+    def approve!
+      self.type = :subscribed
+      morph_to_reply
+    end
+
+    ##
+    # Create a refuse stanza
+    def refuse!
+      self.type = :unsubscribed
+      morph_to_reply
+    end
+
+    ##
+    # Create an unsubscribe stanza
+    def unsubscribe!
+      self.type = :unsubscribe
+      morph_to_reply
+    end
+
+    ##
+    # Create a cancel stanza
+    def cancel!
+      self.type = :unsubscribed
+      morph_to_reply
+    end
+
+    ##
+    # Create a request stanza
+    def request!
+      self.type = :subscribe
+      morph_to_reply
+    end
+
+    def request?
+      self.type == :subscribe
+    end
+
+  private
+    def morph_to_reply
+      self.to = self.from if self.from
+      self.from = nil
+      self
+    end
+  end #Subscription
+
+end #Presence
+end #Stanza
+end

data/lib/blather/core/stream.rb

@@ -0,0 +1,181 @@
+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) # :nodoc:
+      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 # :nodoc:
+#      @keepalive = EM::Timer.new(60) { send_data ' ' }
+      @state = :stopped
+      dispatch
+    end
+
+    def receive_data(data) # :nodoc:
+      @parser.parse data
+
+    rescue => e
+      @client.respond_to?(:rescue) ? @client.rescue(e) : raise(e)
+    end
+
+    def unbind # :nodoc:
+#      @keepalive.cancel
+      @state == :stopped
+    end
+
+    def receive(node) # :nodoc:
+      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
+
+    ##
+    # Send data over the wire
+    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) # :nodoc:
+      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