cancer 0.1.0.a1

data/lib/cancer/xep.rb

@@ -0,0 +1,43 @@
+
+module Cancer
+  module XEP
+    
+    def self.xeps
+      @xeps ||= {}
+    end
+    
+    def self.register(name, mod_name)
+      self.xeps[name.to_s] = mod_name
+    end
+    
+    def self.[](name)
+      self.xeps[name.to_s]
+    end
+    
+    def self.const_for(name)
+      mod_name = self[name]
+      raise Cancer::XEP::LoadError.new(name) unless mod_name
+      
+      mod_name.sub!(/^[:]{2}/, '')
+      eval("::#{mod_name}")
+      
+    rescue NameError => e
+      if e.message.include?(mod_name)
+        raise Cancer::XEP::LoadError.new(name, mod_name)
+      else
+        raise e
+      end
+    end
+    
+    def self.included(base)
+      base.send(:include, Cancer::Dependencies)
+    end
+    
+    class LoadError < Cancer::CancerError
+      def initialize(xep_name, mod_name=nil)
+        super("failed to load #{xep_name}"+(mod_name ? " (#{mod_name})" : ''))
+      end
+    end
+    
+  end
+end

data/lib/cancer/xeps/core.rb

@@ -0,0 +1,109 @@
+
+module Cancer
+  # Core XMPP protocol
+  # http://tools.ietf.org/html/draft-ietf-xmpp-3920bis-02
+  module Core
+    include Cancer::XEP
+    
+    autoload :Stream,     'cancer/xeps/core/stream'
+    autoload :TLS,        'cancer/xeps/core/tls'
+    autoload :SASL,       'cancer/xeps/core/sasl'
+    autoload :Bind,       'cancer/xeps/core/bind'
+    autoload :Session,    'cancer/xeps/core/session'
+    autoload :Terminator, 'cancer/xeps/core/terminator'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::Core::StreamHelper
+      end
+      stream.extend_builder do
+        include Cancer::Core::BuilderHelper
+      end
+      
+      stream.install_controller(Cancer::Core::Stream)
+      stream.install_controller(Cancer::Core::TLS)
+      stream.install_controller(Cancer::Core::SASL)
+      stream.install_controller(Cancer::Core::Bind)
+      stream.install_controller(Cancer::Core::Session)
+      stream.install_controller(Cancer::Core::Terminator)
+    end
+    
+    module StreamHelper
+      
+      def restart_stream
+        send_stream_header
+        throw :halt
+      end
+      
+      def send_stream_header
+        send %(<stream:stream xmlns="#{CLIENT_NS}" xmlns:stream="#{STREAM_NS}" to="#{options[:jid].server_jid}" from="#{options[:jid].bare_jid}" version="1.0">)
+      end
+      
+      def start_tls
+        @adapter.start_tls
+      end
+      
+      def send_iq(to, type=:get, id=nil, from=nil, &proc)
+        iq = build do |x|
+          x.iq(to, type, id, from) do
+            proc.call(x) if proc
+          end
+        end
+        
+        if type == :result or type == :error
+          send iq
+        else
+          send_and_receive(iq) { |x| x.named?('iq', CLIENT_NS) and (x[:id] == iq[:id]) }
+        end
+      end
+      
+      def send_iq_response(original_iq, type = :result, &proc)
+        original_iq = (Cancer::Events::XMLEvent === original_iq ? original_iq.xml : original_iq)
+        to = original_iq['from']
+        id = original_iq['iq']
+        send_iq(to, type, id, &proc)
+      end
+      
+      def send_message(to=nil, type=nil, id=nil, &proc)
+        send do |x|
+          x.message(to, type) do
+            proc.call(x) if proc
+          end
+        end
+      end
+      
+      def next_stanza_id
+        @stanza_id ||= 0
+        @stanza_id += 1
+        "cancer-#{@stanza_id}"
+      end
+    end
+    
+    module BuilderHelper
+      def iq(to=nil, type=nil, id=nil, from=nil, &proc)
+        attributes = {}
+        attributes[:to] = to.to_s if to
+        attributes[:from] = from.to_s if from
+        attributes[:type] = type.to_s if type
+        attributes[:id] = id || @stream.next_stanza_id
+        iq_(attributes, &proc)
+      end
+      
+      def iq_response(original_iq, type = :result, &proc)
+        original_iq = (Cancer::Events::XMLEvent === original_iq ? original_iq.xml : original_iq)
+        to = original_iq['from']
+        id = original_iq['iq']
+        iq(to, type, id, &proc)
+      end
+      
+      def message(to=nil, type=nil, id=nil, &proc)
+        attributes = {}
+        attributes[:to] = to.to_s if to
+        attributes[:type] = type.to_s if type
+        attributes[:id] = id || @stream.next_stanza_id
+        message_(attributes, &proc)
+      end
+    end
+    
+  end
+end

data/lib/cancer/xeps/core/bind.rb

@@ -0,0 +1,33 @@
+
+module Cancer
+  module Core
+    class Bind < Cancer::Controller
+      
+      NS = "urn:ietf:params:xml:ns:xmpp-bind"
+      
+      priority 300
+      
+      on { |e| e.xpath('/s:features/b:bind', 'b' => NS, 's' => STREAM_NS) }
+      def bind_resource(e)
+        resource = options[:jid].resource
+        result = send_iq(nil, :set) do |x|
+          x.bind(:xmlns => NS) do
+            x.resource { x.text resource } if resource
+          end
+        end
+        jid_element = result.first('b:bind/b:jid', 'b' => NS)
+        if jid_element.nil? or result[:type] == 'error'
+          raise "Bind failed: #{result}"
+        end
+        
+        options[:jid].merge! Cancer::JID.parse(jid_element.text).to_hash
+      end
+      
+      on { |e| e.name(:initialized) }
+      def unregister_ourself
+        unregister!
+      end
+      
+    end
+  end
+end

data/lib/cancer/xeps/core/sasl.rb

@@ -0,0 +1,113 @@
+
+require 'rubygems'
+require 'sasl/base'
+require 'sasl'
+autoload :Base64, 'base64'
+
+module Cancer
+  module Core
+    class SASL < Cancer::Controller
+      
+      NS = "urn:ietf:params:xml:ns:xmpp-sasl"
+      
+      priority 200
+      
+      on { |e| e.xpath('/t:features/s:mechanisms/s:mechanism', 's' => NS, 't' => STREAM_NS) }
+      def find_sasl_mechanisms(e)
+        mechanisms = e.xml.all('/stream:features/s:mechanisms/s:mechanism', 's' => NS)
+        @mechanisms = mechanisms.to_a.collect { |e| e.text.upcase }
+        return if @mechanisms.empty?
+        
+        try_sasl_mechanism
+      end
+      
+      on { |e| e.xpath('/n:success', 'n' => NS) }
+      def on_success(e)
+        restart_stream
+      end
+      
+      on { |e| e.xpath('/n:challenge', 'n' => NS) }
+      def on_challenge(e)
+        message, content = *@sasl.receive('challenge', Base64.decode64(e.xml.text))
+        
+        unless message == 'response'
+          try_sasl_mechanism
+        end
+        
+        send do |x|
+          x.response :xmlns => NS do |x|
+            x.text Base64.encode64(content) if content
+          end
+        end
+        
+        throw :halt
+      end
+      
+      on { |e| e.name(:initialized) }
+      def unregister_ourself
+        unregister!
+      end
+      
+      def try_sasl_mechanism
+        if @mechanisms.empty?
+          raise "SASL autentication failed!"
+        end
+        
+        @sasl = ::SASL.new(@mechanisms, Preferences.new(options))
+        @mechanisms.delete(@sasl.mechanism)
+        
+        message, content = *@sasl.start
+        unless message == 'auth'
+          try_sasl_mechanism
+        end
+        
+        send do |x|
+          x.auth :mechanism => @sasl.mechanism, :xmlns => NS do |x|
+            x.text Base64.encode64(content) if content
+          end
+        end
+        
+        throw :halt
+      end
+      
+      class Preferences < ::SASL::Preferences
+        def initialize(options={})
+          @options = options
+        end
+        
+        def authzid
+          nil
+        end
+        
+        def realm
+          @options[:jid].domain
+        end
+        
+        def digest_uri
+          "xmpp/#{@options[:jid].domain}"
+        end
+        
+        def username
+          @options[:jid].bare_jid.to_s
+        end
+        
+        def has_password?
+          !!@options[:password]
+        end
+        
+        def allow_plaintext?
+          true
+        end
+        
+        def password
+          @options[:password]
+        end
+        
+        def want_anonymous?
+          false
+        end
+      end
+      
+    end
+  end
+end

data/lib/cancer/xeps/core/session.rb

@@ -0,0 +1,22 @@
+
+module Cancer
+  module Core
+    class Session < Cancer::Controller
+      
+      NS = "urn:ietf:params:xml:ns:xmpp-session"
+      
+      priority 400
+      
+      on { |e| e.xpath('/t:features/s:session', 's' => NS, 't' => STREAM_NS) }
+      def initiate_session(e)
+        send_iq(nil, :set) { |x| x.session(:xmlns => NS) }
+      end
+      
+      on { |e| e.name(:initialized) }
+      def unregister_ourself
+        unregister!
+      end
+      
+    end
+  end
+end

data/lib/cancer/xeps/core/stream.rb

@@ -0,0 +1,18 @@
+
+module Cancer
+  module Core
+    class Stream < Cancer::Controller
+      
+      on { |e| e.xpath('/n:stream', 'n' => STREAM_NS) }
+      def set_session_id(e)
+        options[:session_id] = e.xml['id']
+      end
+      
+      on { |e| e.name(:initialized) }
+      def unregister_ourself
+        unregister!
+      end
+      
+    end
+  end
+end

data/lib/cancer/xeps/core/terminator.rb

@@ -0,0 +1,21 @@
+
+module Cancer
+  module Core
+    class Terminator < Cancer::Controller
+      
+      priority 500
+      
+      on { |e| e.xpath('/t:features', 't' => STREAM_NS) }
+      def initialization_completed(e)
+        fire! Cancer::Events::NamedEvent, :initialized
+        initialization_completed!
+      end
+      
+      on { |e| e.name(:initialized) }
+      def unregister_ourself
+        unregister!
+      end
+      
+    end
+  end
+end

data/lib/cancer/xeps/core/tls.rb

@@ -0,0 +1,34 @@
+
+module Cancer
+  module Core
+    class TLS < Cancer::Controller
+      
+      NS = "urn:ietf:params:xml:ns:xmpp-tls"
+      
+      priority 100
+      
+      on { |e| e.xpath('/s:features/t:starttls', 't' => NS, 's' => STREAM_NS) }
+      def try_start_tls(e)
+        send { |x| x.starttls :xmlns => NS }
+        throw :halt
+      end
+      
+      on { |e| e.xpath('/t:proceed', 't' => NS) }
+      def start_tls_proceed(e)
+        start_tls
+        restart_stream
+      end
+      
+      on { |e| e.xpath('/t:failure', 't' => NS) }
+      def start_tls_failed(e)
+        raise "TLS connection failed: #{e.xml}"
+      end
+      
+      on { |e| e.name(:initialized) }
+      def unregister_ourself
+        unregister!
+      end
+      
+    end
+  end
+end

data/lib/cancer/xeps/im.rb

@@ -0,0 +1,323 @@
+
+module Cancer
+  # XMPP IM protocol
+  module IM
+    include Cancer::XEP
+    
+    ROSTER_NS = 'jabber:iq:roster'
+    
+    def self.enhance_stream(stream)
+      stream.extend_stream do
+        include Cancer::IM::StreamHelper
+      end
+      stream.install_event_helper Cancer::IM::EventDSL
+      stream.install_controller Cancer::IM::Roster::Controller
+      
+      stream.presence_enhancer_for :priority do |x|
+        x.priority_(self.presence_priority) if self.presence_priority
+      end
+      stream.presence_enhancer_for :show do |x|
+        x.show_(self.presence_show) if self.presence_show
+      end
+      stream.presence_enhancer_for :status do |x|
+        x.status_(self.presence_status) if self.presence_status
+      end
+    end
+    
+    module StreamHelper
+      
+      def roster
+        @roster ||= Roster.new(self)
+      end
+      
+      def peers
+        @peers ||= {}
+      end
+      
+      def presence_enhancers
+        @presence_enhancers ||= []
+      end
+      
+      def presence_enhancer_for(name, &proc)
+        method_name = "enhance_presence_with_#{name}"
+        if self.respond_to?(method_name)
+          raise "#{self} already has a presence enhancer for #{name} (#{method_name})"
+        end
+        
+        metaklass = (class << self ; self; end)
+        metaklass.send(:define_method, method_name, &proc)
+        metaklass.send(:private, method_name)
+        self.presence_enhancers.push(method_name)
+        
+        name
+      end
+      
+      def remove_precense_enhancer_for(name)
+        method_name = "enhance_presence_with_#{name}"
+        
+        if self.respond_to?(method_name)
+          metaklass = (class << self ; self; end)
+          metaklass.send(:remove_method, method_name)
+          self.precense_enhancers.delete(method_name)
+          name
+        end
+      end
+      
+      def update_presence!
+        send do |x|
+          x.presence do
+            
+            self.presence_enhancers.each do |method_name|
+              self.__send__(method_name, x)
+            end
+            
+          end
+        end
+      end
+      
+      attr_accessor :presence_priority
+      attr_accessor :presence_show
+      attr_accessor :presence_status
+      
+    end
+    
+    class Roster
+      include Enumerable
+      
+      def initialize(stream)
+        @stream = stream
+        pull!
+      end
+      
+      def [](jid)
+        @items[jid.to_s]
+      end
+      
+      def each(&proc)
+        @items.values.each(&proc)
+      end
+      
+      def pull!
+        @items = {}
+        
+        result = @stream.send_iq(nil) do |x|
+          x.query :xmlns => ROSTER_NS
+        end
+        
+        namespaces = { 'c' => CLIENT_NS, 'r' => ROSTER_NS }
+        result.all('/c:iq/r:query/r:item', namespaces) do |i|
+          item = Roster::Item.new(i)
+          @items[item.jid] = item
+        end
+        
+        @items
+      end
+      
+      def push!(iq)
+        namespaces = { 'c' => CLIENT_NS, 'r' => ROSTER_NS }
+        iq.all('/c:iq/r:query/r:item', namespaces) do |i|
+          if i[:subscription].to_s == 'remove'
+            @items.delete(i[:jid].to_s)
+          else
+            item = Roster::Item.new(i)
+            @items[item.jid] = item
+          end
+        end
+      end
+      
+      def save(jid, options={})
+        subscription = options.delete(:subscription)
+        needs_roster = (!options.empty?) or (@items[jid.to_s].nil?)
+        
+        if needs_roster
+          groups = options.delete(:groups) || []
+          @stream.send_iq(nil, :set) do |x|
+            x.query :xmlns => ROSTER_NS do
+              x.item(options.merge(:jid => jid)) do
+                groups.each { |group| x.group(group) }
+              end
+            end
+          end
+        end
+        
+        unless subscription.nil?
+          subscription = case subscription
+          when TrueClass  then :subscribe
+          when FalseClass then :unsubscribe
+          else subscription
+          end
+          @stream.send { |x| x.presence(:to => jid, :type => subscription.to_s) }
+        end
+      end
+      
+      def create(jid, options={})
+        raise "Roster item #{jid} already exists!" if @items[jid.to_s]
+        save(jid, options)
+      end
+      
+      def update(jid, options={})
+        raise "Roster item #{jid} doesn't exists yet!" unless @items[jid.to_s]
+        save(jid, options)
+      end
+      
+      def delete(jid_or_item)
+        jid = (Roster::Item === jid_or_item ? jid_or_item.jid.to_s : jid_or_item.to_s)
+        
+        raise "Roster item #{jid} doesn't exists yet!" unless @items[jid]
+        
+        @stream.send_iq(nil, :set) do |x|
+          x.query :xmlns => ROSTER_NS do
+            x.item(:jid => jid, :subscription => 'remove')
+          end
+        end
+      end
+      
+      class Item
+        attr_reader :jid, :name, :subscription, :groups, :peers
+        def initialize(options={})
+          @jid                  = (options[:jid].to_s            rescue nil)
+          @name                 = (options[:name].to_s           rescue nil)
+          @subscription         = (options[:subscription].to_sym rescue :none)
+          @pending_subscription = ('subscribe' == options[:ask])
+          @peers                = []
+          @groups = case options
+          when Nokogiri::XML::Node
+            options.all('r:group', 'r' => ROSTER_NS).collect { |g| g.text.to_s }
+          else options[:groups]
+          end
+        end
+        
+        def pending_subscription?
+          @pending_subscription || false
+        end
+      end
+      
+      class Controller < Cancer::Controller
+        
+        on(:priority => 1000) { |e| e.name(:initialized) }
+        def broadcast
+          update_presence!
+        end
+        
+        NAMESPACES = { 'c' => CLIENT_NS, 'r' => ROSTER_NS }
+        on { |e| e.xpath('/c:iq[@type="set"]/r:query/r:item', NAMESPACES) }
+        def roster_push(e)
+          roster.push!(e.xml)
+          
+          send_iq(e.sender, :result, e.id)
+          
+          throw :halt
+        end
+        
+        on(:priority => 5) { |e| e.xpath('/c:presence', 'c' => CLIENT_NS) }
+        def received_precense(e)
+          peer = self.peers[e.sender] || Peer.load(e.xml)
+          
+          case (e.xml[:type] || :available).to_sym
+          
+          when :available
+            peer = Peer.load(e.xml)
+            self.peers[e.sender] = peer
+            self.roster[e.sender.bare_jid].peers.push(peer) if self.roster[e.sender.bare_jid]
+            fire! PrecenceEvent, self, peer, :available, e.xml
+          when :unavailable
+            self.peers.delete(e.sender)
+            self.roster[e.sender.bare_jid].peers.delete(peer) if self.roster[e.sender.bare_jid]
+            fire! PrecenceEvent, self, peer, :unavailable, e.xml
+          
+          when :subscribe
+            fire! PrecenceEvent, self, peer, :subscribe, e.xml
+          when :subscribed
+            fire! PrecenceEvent, self, peer, :subscribed, e.xml
+          
+          when :unsubscribe
+            fire! PrecenceEvent, self, peer, :unsubscribe, e.xml
+          when :unsubscribed
+            fire! PrecenceEvent, self, peer, :unsubscribed, e.xml
+          
+          when :probe
+          when :error
+          
+          end
+        end
+        
+      end
+    end
+    
+    class Peer
+      attr_accessor :jid, :show, :status
+      
+      def self.load(presence)
+        new.load(presence)
+      end
+      
+      def load(presence)
+        @jid    = presence[:from].to_s.to_jid
+        @show   = (presence.first('./c:show/text()').to_sym rescue nil)
+        @status = (presence.first('./c:status/text()').to_s rescue nil)
+        self
+      end
+    end
+    
+    class PrecenceEvent < Cancer::Events::AbstractEvent
+      attr_reader :peer, :action, :xml
+      def initialize(controller, peer, action, xml)
+        @controller, @peer, @action, @xml = controller, peer, action, xml
+      end
+    end
+    
+    class PrecenceEventMatcher < Cancer::Events::Matcher
+      
+      def initialize(options={})
+        @action = options[:action]
+      end
+      
+      def match?(event)
+        Cancer::IM::PrecenceEvent === event and match_action?(event)
+      end
+      
+      def match_action?(event, pattern=@action)
+        case pattern
+        when Symbol   then event.action.to_sym == pattern
+        when String   then event.action.to_s == pattern
+        when Array    then pattern.any? { |p| match_profile?(event, p) }
+        when NilClass then true
+        end
+      end
+      
+    end
+    
+    module EventDSL
+      
+      def presence(options={})
+        Cancer::IM::PrecenceEventMatcher.new(options)
+      end
+      
+      def peer_available(options={})
+        presence(options.merge(:action => :available))
+      end
+      
+      def peer_unavailable(options={})
+        presence(options.merge(:action => :unavailable))
+      end
+      
+      def subscription_request(options={})
+        presence(options.merge(:action => :subscribe))
+      end
+      
+      def subscription_granted(options={})
+        presence(options.merge(:action => :subscribed))
+      end
+      
+      def unsubscription_request(options={})
+        presence(options.merge(:action => :unsubscribe))
+      end
+      
+      def subscription_revoked(options={})
+        presence(options.merge(:action => :unsubscribed))
+      end
+      
+    end
+    
+  end
+end