cancer 0.1.0.a1

data/lib/cancer/spec/mock_adapter.rb

@@ -0,0 +1,139 @@
+module Cancer
+  module Spec
+    
+    class MockAdapter < Cancer::Adapter
+      class << self
+        attr_accessor :transcript, :instance, :dialog
+      end
+      
+      def self.mock(&dialog)
+        mock = Class.new(self)
+        mock.dialog = dialog
+        mock
+      end
+      
+      def self.should_produce_transcript(&proc)
+        should Cancer::Spec::Matcher.new(Cancer::Spec::Transcript.new(&proc))
+      rescue ::Spec::Expectations::ExpectationNotMetError => e
+        if $cancer_error
+          if $cancer_error.backtrace and $cancer_error != e
+            e.backtrace.clear
+            e.backtrace.concat($cancer_error.backtrace)
+          end
+          $cancer_error = nil
+        end
+        if !Cancer::Spec.debug
+          backtrace = e.backtrace.dup
+          e.backtrace.clear
+          e.backtrace.concat backtrace.select { |f| !f.include?('spec_helper.rb') }
+        end
+        raise e
+      end
+      
+      def initialize(stream, options={})
+        @stream, @options = stream, options
+        self.class.instance = self
+        @transcript = self.class.transcript.dup
+        @queue = Queue.new
+        @responder_tread = Thread.new do
+          Thread.current.abort_on_exception = true
+          begin
+            run_server_emulation_and_state_verification
+            loop do
+              data = @queue.pop
+              break unless data
+              verify_client_data(data)
+              run_server_emulation_and_state_verification
+            end
+          rescue ::Spec::Expectations::ExpectationNotMetError => e
+            if lock = @stream.instance_variable_get('@lock')
+              $cancer_error ||= e
+              lock.continue!(e)
+            elsif locks = @stream.instance_variable_get('@receive_locks') and lock = locks.first
+              $cancer_error ||= e
+              lock.continue!(e)
+            else
+              $cancer_error ||= e
+            end
+          end
+        end
+      end
+      
+      def connect
+      end
+      
+      def start_tls?
+      end
+      
+      def start_tls
+      end
+      
+      def disconnect
+        @queue.push(nil)
+        @responder_tread.join
+        
+        if $cancer_error
+          raise $cancer_error
+        elsif @transcript.first
+          messages  = ""
+          backtrace = nil
+          while message = @transcript.pop
+            case message.first
+            when :in     then messages += "      in: #{message[1]}\n"
+            when :out    then messages += "     out: #{message[1]}\n"
+            when :verify then messages += "  verify: #{(message[2] || message[3]).first}\n"
+            end
+            backtrace ||= message.last
+          end
+          raise Cancer::Spec::Error.new("Expected a longer dialog:\n#{messages}", backtrace)
+        end
+      end
+      
+      def send(data)
+        @queue.push(data)
+      end
+      
+      def verify_client_data(xml)
+        type, data, backtrace = @transcript.pop
+        
+        if type == nil
+          raise Cancer::Spec::Error.new("Unexpected data send by client:\n  #{xml}")
+        end
+        
+        if type != :out
+          raise Cancer::Spec::Error.new("should be write instead of #{type}", backtrace)
+        end
+        
+        a = (Nokogiri::XML.parse(data).root rescue data) || data
+        b = (Nokogiri::XML.parse(xml).root  rescue xml)  || xml
+        
+        a.strip_empty_text! if Nokogiri::XML::Node === a
+        
+        if Nokogiri::XML::Node === b and Nokogiri::XML::Node === a
+          if !b.matching?(a)
+            raise Cancer::Spec::Error.new("Expected xml-data doesn't match the actual xml-data!\n  expected: #{data}\n    actual: #{xml}", backtrace)
+          end
+        elsif a != b
+          raise Cancer::Spec::Error.new("Expected xml-data doesn't match the actual xml-data!\n  expected: #{data}\n    actual: #{xml}", backtrace)
+        end
+      end
+      
+      def run_server_emulation_and_state_verification
+        while @transcript.first and @transcript.first[0] != :out
+          type, data, backtrace = @transcript.pop
+          return if type == nil
+          case type
+          when :in
+            if Proc === data
+              @stream.received_data(stream.build(&data))
+            else
+              @stream.received_data(data)
+            end
+          when :verify then data.call(@stream)
+          end
+        end
+      end
+    end
+    
+  end
+end

data/lib/cancer/spec/mock_stream.rb

@@ -0,0 +1,15 @@
+module Cancer
+  module Spec
+    
+    class MockStream < Cancer::Spec::MockAdapter
+      def self.should_produce_transcript
+        super() do |t|
+          t.initiate_stream('alice@wonderland.lit')
+          yield(t)
+          t.close_stream
+        end
+      end
+    end
+    
+  end
+end

data/lib/cancer/spec/transcript.rb

@@ -0,0 +1,107 @@
+module Cancer
+  module Spec
+    
+    class Transcript
+      
+      def initialize(entries=nil)
+        @entries = entries || []
+        yield(self) if block_given?
+      end
+      
+      def dup
+        self.class.new(@entries.dup)
+      end
+      
+      def in(xml, backtrace=nil)
+        @entries.push [:in, xml, backtrace||caller]
+      end
+      
+      def out(xml, backtrace=nil)
+        @entries.push [:out, xml, backtrace||caller]
+      end
+      
+      def verify(&proc)
+        @entries.push [:verify, proc, nil, caller]
+      end
+      
+      def should(matcher)
+        @entries.push [:verify, lambda { |stream| stream.should matcher }, caller]
+      end
+      
+      def should_not(matcher)
+        @entries.push [:verify, lambda { |stream| stream.should_not matcher }, caller]
+      end
+      
+      def start_stream(from, to=nil, id=nil, backtrace=nil)
+        backtrace = backtrace || caller
+        from = from.to_jid
+        to ||= from.server_jid
+        id ||= rand(6000).to_s
+        self.out %{<stream:stream xmlns="jabber:client" xmlns:stream="http://etherx.jabber.org/streams" to="#{to}" from="#{from.bare_jid}" version="1.0">}, backtrace
+        self.in  %{<stream:stream xmlns="jabber:client" xmlns:stream="http://etherx.jabber.org/streams" from="to" to="#{from.bare_jid}" id="#{id}" version="1.0">}, backtrace
+      end
+      
+      def close_stream(backtrace=nil)
+        backtrace = backtrace || caller
+        self.out %{</stream:stream>}, backtrace
+        self.in  %{</stream:stream>}, backtrace
+      end
+      
+      def initiate_stream(from, to=nil, id=nil, backtrace=nil)
+        backtrace = backtrace || caller
+        from = from.to_jid
+        
+        self.start_stream(from, to, id, backtrace)
+        self.in %{<stream:features> 
+  <starttls xmlns="urn:ietf:params:xml:ns:xmpp-tls"> 
+    <optional/> 
+  </starttls> 
+  <mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"> 
+    <mechanism>PLAIN</mechanism>
+    <required/> 
+  </mechanisms> 
+</stream:features>}, backtrace
+
+        self.out %{<starttls xmlns="urn:ietf:params:xml:ns:xmpp-tls"/>}, backtrace
+        self.in  %{<proceed xmlns="urn:ietf:params:xml:ns:xmpp-tls"/>}, backtrace
+            
+        self.start_stream(from, to, id, backtrace)
+        self.in %{<stream:features> 
+  <mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"> 
+    <mechanism>PLAIN</mechanism>
+    <required/> 
+  </mechanisms> 
+</stream:features>}, backtrace
+        
+        self.out %{<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="PLAIN">AGFsaWNlQHdvbmRlcmxhbmQubGl0AGloYXRldGhlcXVlZW4=</auth>}, backtrace
+        self.in  %{<success xmlns="urn:ietf:params:xml:ns:xmpp-sasl" />}, backtrace
+        
+        self.start_stream(from, to, id, backtrace)
+        self.in %{<stream:features> 
+    <bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"> 
+      <required/> 
+    </bind> 
+    <session xmlns="urn:ietf:params:xml:ns:xmpp-session"> 
+      <optional/> 
+    </session> 
+</stream:features>}, backtrace
+        
+        self.out %{<iq type="set" id="cancer-1"><bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"/></iq>}, backtrace
+        self.in  %{<iq type="result" id="cancer-1"><bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"><jid>#{from.bare_jid}/#{from.resource || 'rabbithole'}</jid></bind></iq>}, backtrace
+        
+        self.out %{<iq type="set" id="cancer-2"><session xmlns="urn:ietf:params:xml:ns:xmpp-session"/></iq>}, backtrace
+        self.in  %{<iq type="result" id="cancer-2" />}, backtrace
+        
+      end
+      
+      def first
+        @entries.first
+      end
+      
+      def pop
+        @entries.shift
+      end
+    end
+    
+  end
+end

data/lib/cancer/stream.rb

@@ -0,0 +1,182 @@
+
+module Cancer
+  class Stream
+    
+    autoload :XEP,         'cancer/stream/xep'
+    autoload :Builder,     'cancer/stream/builder'
+    autoload :Controller,  'cancer/stream/controller'
+    autoload :EventHelper, 'cancer/stream/event_helper'
+    
+    include Cancer::SynchronizedStanza
+    include Cancer::Stream::Controller
+    include Cancer::Stream::Builder
+    include Cancer::Stream::XEP
+    include Cancer::Stream::EventHelper
+    extend  Cancer::Support
+    include Cancer::Events::Eventable
+    
+    attr_accessor :options
+    
+    def self.open(options={},&proc)
+      new(options).open(&proc)
+    end
+    
+    def initialize(options={})
+      
+      options[:jid] = options[:jid].to_jid if options[:jid]
+      options[:adapter] ||= Cancer::Adapters::Socket
+      
+      @options = options
+      @lock    = Cancer::Lock.new
+      @receive_locks = []
+      @mutex = Mutex.new
+      
+      register_with Cancer::Events::Manager.new
+      @low_priority_queue = Cancer::ThreadPool.start!(4) do |job|
+        args, proc = *job
+        proc.call(*args)
+      end
+      
+      @stream_parser = Cancer::StreamParser.new(self)
+      @xml_parser    = Nokogiri::XML::SAX::PushParser.new(@stream_parser)
+      
+      ['core', options[:xeps]].flatten.compact.each do |xep_name|
+        install_xep xep_name
+      end
+      
+      enhance_stream_with_xeps!
+      @manager.resolve_martchers!
+      
+      @initialized = true
+      
+      controller do
+        on { |e| e.exception(Exception) }
+        def err(e)
+          Cancer.logger.error e.exception
+        end
+      end
+      
+      @exception = nil
+    end
+    
+    def deferred(*args, &proc)
+      @manager.deferred(*args, &proc)
+    end
+    
+    def enqueue(*args, &proc)
+      @low_priority_queue.push([args, proc])
+    end
+    
+    def fire!(*args)
+      @manager.fire!(*args)
+    end
+    
+    def handle_interthread_exceptions
+      raise @exception if @exception
+    end
+    
+    def extend_stream(&proc)
+      metaklass = (class << self ; self ; end)
+      metaklass.instance_eval(&proc)
+    end
+    
+    def send(stanza=nil, &proc)
+      handle_interthread_exceptions
+      stanza ||= proc
+      if Proc === stanza
+        send build(&stanza)
+      else
+        send_data stanza.to_s.gsub(/>[\n\s]+/m, '>').gsub(/[\n\s]+</m, '<')
+      end
+    end
+    
+    def received_data(data)
+      data = process_received_data(data)
+      @xml_parser << data
+      
+    rescue RuntimeError => e
+      if data[0, 5] == "<?xml" or data[0, 14] == "<stream:stream"
+        @xml_parser = Nokogiri::XML::SAX::PushParser.new(@stream_parser)
+        @xml_parser << data
+      else
+        raise e
+      end
+    end
+    
+    def received_xml(xml)
+      Cancer.logger.debug "RECEIVED: #{xml}"
+      handle_stream_errors(xml) or
+      handle_synchronized_stanza(xml) or
+      @manager.fire!(Cancer::Events::XMLEvent, xml)
+    end
+    
+    def handle_stream_errors(xml)
+      return unless xml.named?('error', STREAM_NS)
+      
+      @exception = Cancer::StreamError.new(xml)
+      handle_synchronized_stanza(@exception)
+      if @lock
+        @lock.continue!(@exception)
+      end
+      
+      true
+    end
+    
+    def open
+      handle_interthread_exceptions
+      
+      resolve_options(options)
+      
+      @manager.start!
+      @adapter = options[:adapter].new(self, @options)
+      @adapter.connect
+      @manager.fire!(Cancer::Events::NamedEvent, :connected)
+      
+      send_stream_header
+      @lock.wait!
+      @lock = nil
+      if block_given?
+        yield(self)
+        close
+      end
+      self
+    end
+    
+    def close
+      handle_interthread_exceptions
+      
+      @low_priority_queue.stop!
+      
+      @adapter.send('</stream:stream>')
+      @adapter.disconnect
+      
+      @manager.stop!
+      
+      self
+    end
+    
+    def initialization_completed!
+      @lock.continue!
+    end
+    
+  private
+    
+    def resolve_options(options)
+      options[:username] ||= options[:jid].user
+    end
+    
+    def process_received_data(data)
+      data
+    end
+    
+    def process_send_data(data)
+      data
+    end
+    
+    def send_data(data)
+      Cancer.logger.debug "SEND: #{data.to_s}"
+      @adapter.send(process_send_data(data))
+    end
+    
+  end
+end

data/lib/cancer/stream/builder.rb

@@ -0,0 +1,20 @@
+
+module Cancer
+  class Stream
+    module Builder
+      
+      def builder_helpers
+        @builder_helpers ||= Module.new
+      end
+      
+      def extend_builder(&proc)
+        self.builder_helpers.module_eval(&proc)
+      end
+      
+      def build(builder=nil, &proc)
+        Cancer::Builder.new(self, builder, self.builder_helpers, &proc).doc.root
+      end
+      
+    end
+  end
+end