sprsquish-blather 0.1

data/CHANGELOG

@@ -0,0 +1 @@
+v0.1 Initial release (birth!)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jeff Smick
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Blather
+
+An evented XMPP library

data/blather.gemspec

@@ -0,0 +1,73 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.rubyforge_project = 'squishtech'
+
+  s.name = 'blather'
+  s.description = 'An evented XMPP library written on EventMachine and libxml-ruby'
+  s.summary = 'Evented XMPP library'
+  s.version = '0.1'
+  s.date = '2008-11-17'
+
+  s.authors = ['Jeff Smick']
+  s.email = 'jeff.smick@squishtech.com'
+
+  s.files = %w[
+    README.rdoc
+    CHANGELOG
+    blather.gemspec
+    examples/echo.rb
+    examples/shell_client.rb
+    lib/blather/callback.rb
+    lib/blather/client.rb
+    lib/blather/core/errors.rb
+    lib/blather/core/jid.rb
+    lib/blather/core/roster.rb
+    lib/blather/core/roster_item.rb
+    lib/blather/core/stanza.rb
+    lib/blather/core/stanzas/error.rb
+    lib/blather/core/stanzas/iq.rb
+    lib/blather/core/stanzas/iqs/queries/roster.rb
+    lib/blather/core/stanzas/iqs/query.rb
+    lib/blather/core/stanzas/message.rb
+    lib/blather/core/stanzas/presence.rb
+    lib/blather/core/stanzas/presences/status.rb
+    lib/blather/core/stanzas/presences/subscription.rb
+    lib/blather/core/stream.rb
+    lib/blather/core/streams/parser.rb
+    lib/blather/core/streams/resource.rb
+    lib/blather/core/streams/sasl.rb
+    lib/blather/core/streams/session.rb
+    lib/blather/core/streams/tls.rb
+    lib/blather/core/sugar.rb
+    lib/blather/core/xmpp_node.rb
+    lib/blather/extensions/last_activity.rb
+    lib/blather/extensions/version.rb
+    lib/blather.rb
+    LICENSE
+  ]
+
+  s.test_files = %w[
+    lib/autotest/discover.rb
+    lib/autotest/spec.rb
+    spec/blather/core/jid_spec.rb
+    spec/blather/core/roster_item_spec.rb
+    spec/blather/core/roster_spec.rb
+    spec/blather/core/stanza_spec.rb
+    spec/blather/core/stream_spec.rb
+    spec/blather/core/xmpp_node_spec.rb
+    spec/spec_helper.rb
+  ]
+
+  s.extra_rdoc_files = %w[
+    README.rdoc
+    CHANGELOG
+    LICENSE
+  ]
+
+  s.has_rdoc = true
+  s.rdoc_options = %w[--line-numbers --inline-source --title Blather --main README]
+
+  s.add_dependency('eventmachine', ['> 0.0.0'])
+  s.add_dependency('libxml', ['> 0.0.0'])
+end

data/lib/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { 'spec' }

data/lib/autotest/spec.rb

@@ -0,0 +1,60 @@
+require 'autotest'
+
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+  # watch out: Ruby bug (1.8.6):
+  # %r(/) != /\//
+  at.add_mapping(%r%^spec/.*_spec.rb$%) { |filename, _|
+    filename
+  }
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m|
+    ["spec/#{m[1]}_spec.rb"]
+  }
+  at.add_mapping(%r%^spec/(spec_helper|shared/.*)\.rb$%) { 
+    at.files_matching %r%^spec/.*_spec\.rb$%
+  }
+end
+
+BAR       = "=" * 78
+REDCODE   = 31
+GREENCODE = 32
+
+Autotest.add_hook :ran_command do |at|
+  at.results.last =~ /^.* (\d+) failures, (\d+) errors/
+
+  code = ($1 == "0" and $2 == "0") ? GREENCODE : REDCODE
+  puts "\e[#{ code }m#{ BAR }\e[0m\n\n"
+end
+
+class Autotest::Spec < Autotest
+  def path_to_classname(s)
+    sep = File::SEPARATOR
+    f = s.sub(/spec#{sep}/, '').sub(/(spec)?\.rb$/, '').split(sep)
+    f = f.map { |path| path.split(/_|(\d+)/).map { |seg| seg.capitalize }.join }
+    f = f.delete_if { |path| path == 'Core' }
+    f.join
+  end
+
+  ##
+  # Returns a hash mapping a file name to the known failures for that
+  # file.
+
+  def consolidate_failures(failed)
+    filters = new_hash_of_arrays
+
+    class_map = Hash[*self.find_order.grep(/^spec/).map { |f| # TODO: ugly
+                       [path_to_classname(f), f]
+                     }.flatten]
+    class_map.merge!(self.extra_class_map)
+
+    failed.each do |method, klass|
+      if class_map.has_key? klass then
+        filters[class_map[klass]] << method
+      else
+        output.puts "Unable to map class #{klass} to a file"
+      end
+    end
+
+    return filters
+  end
+end

data/lib/blather/callback.rb

@@ -0,0 +1,24 @@
+module Blather
+
+  class Callback
+    include Comparable
+
+    attr_accessor :priority
+
+    def initialize(priority = 0, &callback)
+      @priority = priority
+      @callback = callback
+    end
+
+    def call(*args)
+      @callback.call(*args)
+    end
+
+    # Favor higher numbers
+    def <=>(o)
+      self.priority <=> o.priority
+    end
+
+  end #Callback
+
+end

data/lib/blather/client.rb

@@ -0,0 +1,81 @@
+require File.join(File.dirname(__FILE__), %w[.. blather])
+
+module Blather
+
+  class Client
+    @@callbacks = {}
+    @@status = nil
+
+    attr_accessor :jid,
+                  :roster
+
+    def send_data(data)
+      @stream.send data
+    end
+
+    def status
+      @@status
+    end
+
+    def set_status(state = nil, msg = nil, to = nil)
+      status = Presence::Status.new state, msg
+      status.to = to
+      @@status = status unless to
+
+      send_data status
+    end
+
+    def stream_started(stream)
+      @stream = stream
+      retreive_roster
+    end
+
+    def call(stanza)
+      stanza.callback_heirarchy.each { |type| break if callback(type, stanza) }
+    end
+
+    # Default response to an Iq 'get' or 'set' is 'service-unavailable'/'cancel'
+    def receive_iq(iq)
+      send_data(ErrorStanza.new_from(iq, 'service-unavailable', 'cancel').reply!) if [:set, :get].include?(iq.type)
+    end
+
+    def receive_roster(node)
+      if !@roster && node.type == :result
+        self.roster = Roster.new(@stream, node)
+        register_callback(:status, -128) { |_, status| roster[status.from].status = status if roster[status.from]; false }
+        set_status
+      elsif node.type == :set
+        roster.process node
+      end
+    end
+
+    def self.register_callback(type, priority = 0, &callback)
+      @@callbacks[type] ||= []
+      @@callbacks[type] << Callback.new(priority, &callback)
+      @@callbacks[type].sort!
+    end
+
+    def register_callback(type, priority = 0, &callback)
+      self.class.register_callback(type, priority = 0, &callback)
+    end
+
+    def self.status(state = nil, msg = nil)
+      @@status = Presence::Status.new state, msg
+    end
+
+    def callback(type, stanza)
+      complete = false
+      (@@callbacks[type] || []).each { |callback| break if complete = callback.call(self, stanza) }
+
+      method = "receive_#{type}"
+      complete = __send__(method, stanza) if !complete && respond_to?(method)
+      complete
+    end
+
+    def retreive_roster
+      send_data Iq::Roster.new
+    end
+
+  end #Client
+
+end

data/lib/blather/core/errors.rb

@@ -0,0 +1,24 @@
+module Blather
+  # Main error class
+  class BlatherError < StandardError; end
+
+    # Stream errors
+    class StreamError < BlatherError
+      attr_accessor :type, :text
+
+      def initialize(node)
+        @type = node.detect { |n| n.name != 'text' && n['xmlns'] == 'urn:ietf:params:xml:ns:xmpp-streams' }
+        @text = node.detect { |n| n.name == 'text' }
+
+        @extra = node.detect { |n| n['xmlns'] != 'urn:ietf:params:xml:ns:xmpp-streams' }
+      end
+
+      def to_s
+        "Stream Error (#{type.name}) #{"[#{@extra.name}]" if @extra}: #{text.content if text}"
+      end
+    end
+
+    # Stanza errors
+    class StanzaError < StandardError; end
+      class ArgumentError < StanzaError; end
+end

data/lib/blather/core/jid.rb

@@ -0,0 +1,105 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+module Blather
+  ##
+  # The JID class represents a Jabber Identifier as described by
+  # RFC3920 section 3.1.
+  #
+  # Note that you can use JIDs also for Sorting, Hash keys, ...
+  class JID
+    include Comparable
+
+    PATTERN = /^(?:([^@]*)@)??([^@\/]*)(?:\/(.*?))?$/
+
+    begin
+      require 'idn'
+      USE_STRINGPREP = true
+    rescue LoadError
+      USE_STRINGPREP = false
+    end
+
+    # Get the JID's node
+    attr_reader :node
+
+    # Get the JID's domain
+    attr_reader :domain
+
+    # Get the JID's resource
+    attr_reader :resource
+
+    def self.new(node, domain = nil, resource = nil)
+      node.is_a?(JID) ? node : super
+    end
+
+    ##
+    # Create a new JID. If called as new('a@b/c'), parse the string and
+    # split (node, domain, resource)
+    def initialize(node, domain = nil, resource = nil)
+      @resource = resource
+      @domain = domain
+      @node = node
+
+      if @domain.nil? && @resource.nil?
+        @node, @domain, @resource = @node.to_s.scan(PATTERN).first
+      end
+
+      if USE_STRINGPREP
+        @node = IDN::Stringprep.nodeprep(@node)             if @node
+        @domain = IDN::Stringprep.nameprep(@domain)         if @domain
+        @resource = IDN::Stringprep.resourceprep(@resource) if @resource
+      else
+        @node.downcase!   if @node
+        @domain.downcase! if @domain
+      end
+
+      raise ArgumentError, 'Node too long'      if (@node || '').length > 1023
+      raise ArgumentError, 'Domain too long'    if (@domain || '').length > 1023
+      raise ArgumentError, 'Resource too long'  if (@resource || '').length > 1023
+    end
+
+    ##
+    # Returns a string representation of the JID
+    # * ""
+    # * "domain"
+    # * "node@domain"
+    # * "domain/resource"
+    # * "node@domain/resource"
+    def to_s
+      s = @domain
+      s = "#{@node}@#{s}" if @node
+      s = "#{s}/#{@resource}" if @resource
+      return s
+    end
+
+    ##
+    # Returns a new JID with resource removed.
+    # return:: [JID]
+    def stripped
+      self.class.new @node, @domain
+    end
+
+    ##
+    # Removes the resource (sets it to nil)
+    # return:: [JID] self
+    def strip!
+      @resource = nil
+      self
+    end
+
+    ##
+    # Compare two JIDs,
+    # helpful for sorting etc.
+    #
+    # String representations are compared, see JID#to_s
+    def <=>(o)
+      to_s <=> o.to_s
+    end
+
+    # Test id jid is strepped
+    def stripped?
+      @resource.nil?
+    end
+  end
+end

data/lib/blather/core/roster.rb

@@ -0,0 +1,62 @@
+module Blather
+
+  class Roster
+    include Enumerable
+
+    def initialize(stream, stanza = nil)
+      @stream = stream
+      @items = {}
+      stanza.items.each { |i| push i, false } if stanza
+    end
+
+    def process(stanza)
+      stanza.items.each do |i|
+        case i.subscription
+        when :remove then @items.delete(key(i.jid))
+        else @items[key(i.jid)] = RosterItem.new(i)
+        end
+      end
+    end
+
+    def <<(elem)
+      push elem
+      self
+    end
+
+    def push(elem, send = true)
+      jid = elem.respond_to?(:jid) ? elem.jid : JID.new(elem)
+      @items[key(jid)] = node = RosterItem.new(elem)
+
+      @stream.send_data(node.to_stanza(:set)) if send
+    end
+    alias_method :add, :push
+
+    def delete(jid)
+      @items.delete key(jid)
+      @stream.send_data Stanza::Iq::Roster.new(:set, Stanza::Iq::Roster::RosterItem.new(jid, nil, :remove))
+    end
+    alias_method :remove, :delete
+
+    def [](jid)
+      items[key(jid)]
+    end
+
+    def each(&block)
+      items.each &block
+    end
+
+    def items
+      @items.dup
+    end
+
+  private
+    def self.key(jid)
+      JID.new(jid).stripped.to_s
+    end
+
+    def key(jid)
+      self.class.key(jid)
+    end
+  end #Roster
+
+end

data/lib/blather/core/roster_item.rb

@@ -0,0 +1,64 @@
+module Blather
+
+  class RosterItem
+    attr_reader :jid,
+                :ask,
+                :statuses
+
+    attr_accessor :name,
+                  :groups
+
+    def initialize(item)
+      @statuses = []
+
+      if item.is_a?(JID)
+        self.jid = item.stripped
+      elsif item.is_a?(XMPPNode)
+        self.jid          = JID.new(item['jid']).stripped
+        self.name         = item['name']
+        self.subscription = item['subscription']
+        self.ask          = item['ask']
+        item.groups.each { |g| self.groups << g }
+      end
+    end
+
+    def jid=(jid)
+      @jid = JID.new(jid).stripped
+    end
+
+    VALID_SUBSCRIPTION_TYPES = [:both, :from, :none, :remove, :to].freeze
+    def subscription=(sub)
+      raise ArgumentError, "Invalid Type (#{sub}), use: #{VALID_SUBSCRIPTION_TYPES*' '}" if
+        sub && !VALID_SUBSCRIPTION_TYPES.include?(sub = sub.to_sym)
+      @subscription = sub ? sub : :none
+    end
+
+    def subscription
+      @subscription || :none
+    end
+
+    def ask=(ask)
+      raise ArgumentError, "Invalid Type (#{ask}), use: #{VALID_SUBSCRIPTION_TYPES*' '}" if ask && (ask = ask.to_sym) != :subscribe
+      @ask = ask ? ask : nil
+    end
+
+    def status=(presence)
+      @statuses.delete_if { |s| s.from == presence.from }
+      @statuses << presence
+      @statuses.sort!
+    end
+
+    def status(resource = nil)
+      top = resource ? @statuses.detect { |s| s.from.resource == resource } : @statuses.first
+    end
+
+    def to_stanza(type = nil)
+      r = Stanza::Iq::Roster.new type
+      n = Stanza::Iq::Roster::RosterItem.new jid, name, subscription, ask
+      r.query << n
+      n.groups = groups
+      r
+    end
+  end #RosterItem
+
+end

data/lib/blather/core/stanza.rb

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