cancer 0.1.0.a1

data/lib/cancer/exceptions.rb

@@ -0,0 +1,53 @@
+
+module Cancer
+  
+  class CancerError < RuntimeError
+  end
+  
+  class XMPPError < CancerError
+    attr_reader :conditions
+    def initialize(xml)
+      text = xml.first('n:text', "n" => 'urn:ietf:params:xml:ns:xmpp-streams')
+      text = text ? text.text.to_s : "Stream error: #{xml}"
+      super(text)
+      @conditions = xml.all('*[name() != "text"]')
+    end
+  end
+  
+  class StreamError < XMPPError
+  end
+  
+  class StanzaError < XMPPError
+    attr_reader :stanza
+    def initialize(xml)
+      super(xml.first('c:error'))
+      @stanza = xml
+    end
+    def self.build(xml)
+      type = xml.first('c:error')[:type]
+      case type
+      when 'cancel'   then StanzaCancelError.new(xml)
+      when 'continue' then StanzaContinueError.new(xml)
+      when 'modify'   then StanzaModifyError.new(xml)
+      when 'auth'     then StanzaAuthError.new(xml)
+      when 'wait'     then StanzaWaitError.new(xml)
+      end
+    end
+  end
+  
+  class StanzaCancelError < StanzaError
+  end
+  
+  class StanzaContinueError < StanzaError
+  end
+  
+  class StanzaModifyError < StanzaError
+  end
+  
+  class StanzaAuthError < StanzaError
+  end
+  
+  class StanzaWaitError < StanzaError
+  end
+  
+end

data/lib/cancer/jid.rb

@@ -0,0 +1,215 @@
+
+require 'uri'
+
+module Cancer
+
+  #
+  # RFC2368, The mailto URL scheme
+  #
+  class JID < URI::Generic
+    include REGEXP
+
+    COMPONENT = [ :scheme, :user, :domain, :resource ].freeze
+
+    RESOURCE_PATTERN = "(?:[^\\/]*)".freeze
+    RESOURCE_REGEXP  = Regexp.new(RESOURCE_PATTERN, 'N').freeze
+    USER_PATTERN     = "(?:#{PATTERN::ESCAPED}|[^@])*".freeze
+    DOMAIN_PATTERN   = "(?:#{PATTERN::ESCAPED}|[^\\/:])".freeze
+    FULL_JID_REGEXP  = Regexp.new(" # :nodoc:
+      \\A
+      (?:
+        (#{USER_PATTERN})@                                    (?# 1: user)
+      )?
+      (#{DOMAIN_PATTERN}*?)                                   (?# 2: domain)
+      (?:
+        \\/(#{RESOURCE_PATTERN}(?:\\/#{RESOURCE_PATTERN})*)   (?# 3: resource)
+      )?
+      \\z
+    ", Regexp::EXTENDED, 'N').freeze
+    
+    def self.parse(string)
+      URI.parse(string[0,5] == 'xmpp:' ? string : 'xmpp:' + string)
+    end
+    
+    def self.build(args)
+      tmp = Util::make_components_hash(self, args)
+
+      if tmp[:user]
+        tmp[:opaque] = tmp.delete(:user) + '@'
+      else
+        tmp[:opaque] = ''
+      end
+
+      if tmp[:domain]
+        tmp[:opaque] << tmp.delete(:domain)
+      else
+        tmp[:opaque] << ''
+      end
+
+      if tmp[:resource]
+        if tmp[:resource][0,1] == '/'
+          tmp[:opaque] << tmp.delete(:resource).to_s
+        else
+          tmp[:opaque] << '/' + tmp.delete(:resource).to_s
+        end
+      end
+
+      return super(tmp)
+    end
+
+    def initialize(*arg)
+      super(*arg)
+
+      if FULL_JID_REGEXP =~ @opaque
+         if arg[-1]
+          self.user = $1
+          self.domain = $2
+          self.resource = $3
+        else
+          set_user($1)
+          set_domain($2)
+          set_resource($3)
+        end
+
+      else
+        raise InvalidComponentError,
+          "unrecognised opaque part for xmpp url: #{@opaque}"
+      end
+    end
+
+    attr_reader :domain, :user
+    attr_reader :resource
+
+    def check_user(v)
+      return true unless v
+      return true if v.size == 0
+
+      if OPAQUE !~ v || /\A#{USER_PATTERN}\z/o !~ v
+        raise InvalidComponentError,
+          "bad component(expected opaque component): #{v}"
+      end
+
+      return true
+    end
+    private :check_user
+
+    def set_user(v)
+      @user = v
+    end
+    protected :set_user
+
+    def user=(v)
+      check_user(v)
+      set_user(v)
+      v
+    end
+
+    def check_domain(v)
+      return true unless v
+      return true if v.size == 0
+
+      if OPAQUE !~ v || /\A#{DOMAIN_PATTERN}*\z/o !~ v
+        raise InvalidComponentError,
+          "bad component(expected opaque component): #{v}"
+      end
+
+      return true
+    end
+    private :check_domain
+
+    def set_domain(v)
+      @domain = v
+    end
+    protected :set_domain
+
+    def domain=(v)
+      check_domain(v)
+      set_domain(v)
+      v
+    end
+
+    def check_resource(v)
+      return true unless v
+      return true if v.size == 0
+
+      if OPAQUE !~ v || 
+          /\A\/?(#{RESOURCE_PATTERN}(?:\/#{RESOURCE_PATTERN})*)\z/o !~ v
+        raise InvalidComponentError,
+          "bad component(expected opaque component): #{v}"
+      end
+
+      return true
+    end
+    private :check_resource
+
+    def set_resource(v)
+      @resource = v
+    end
+    protected :set_resource
+
+    def resource=(v)
+      check_resource(v)
+      set_resource(v)
+      v
+    end
+
+    def to_s(include_scheme=false)
+      (include_scheme ? @scheme + ':' : '') + (@user ? @user + '@' : '') + (@domain ? @domain : '') + (@resource ? '/' + @resource : '')
+    end
+    
+    def server_jid!
+      self.resource = nil
+      self.user     = nil
+      self
+    end
+    
+    def server_jid
+      Cancer::JID.build([nil, @domain, nil])
+    end
+    
+    def component_jid(name)
+      Cancer::JID.build([nil, (name + '.' + @domain), nil])
+    end
+    
+    def bare_jid!
+      self.resource = nil
+      self
+    end
+    
+    def bare_jid
+      Cancer::JID.build([@user, @domain, nil])
+    end
+    
+    def merge!(options={})
+      self.user     = options[:user]     if options.key? :user
+      self.domain   = options[:domain]   if options.key? :domain
+      self.resource = options[:resource] if options.key? :resource
+      self
+    end
+    
+    def merge(options={})
+      Cancer::JID.build([options[:user] || @user, options[:domain] || @domain, options[:resource] || @resource])
+    end
+    
+    def to_jid
+      self
+    end
+    
+    def to_hash
+      hash = { :user => @user, :domain => @domain, :resource => @resource }
+      hash.keys.each { |k| hash.delete(k) if hash[k].nil? }
+      hash
+    end
+    
+  end
+end
+
+module URI
+  @@schemes['XMPP'] = Cancer::JID
+end
+
+class String
+  def to_jid
+    Cancer::JID.parse(self) rescue nil
+  end
+end

data/lib/cancer/lock.rb

@@ -0,0 +1,32 @@
+
+module Cancer
+  class Lock
+    
+    def initialize(&proc)
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @proc = proc
+      @values = []
+    end
+    
+    def wait!
+      @mutex.synchronize do
+        @condition.wait(@mutex)
+        if @values.size == 1 and Exception === @values.first
+          raise @values.first
+        else
+          @proc.call(*@values) if @proc
+          return *@values
+        end
+      end
+    end
+    
+    def continue!(*values)
+      @mutex.synchronize do
+        @values = values
+        @condition.signal
+      end
+    end
+    
+  end
+end

data/lib/cancer/spec.rb

@@ -0,0 +1,35 @@
+
+require 'cancer/spec/extentions'
+
+module Cancer
+  # A set of tools to test Cancer using rspec.
+  # 
+  #   Spec::Runner.configure do |config|
+  #     config.include(Cancer::Spec)
+  #   end
+  module Spec
+    
+    autoload :Error,       'cancer/spec/error'
+    autoload :Matcher,     'cancer/spec/matcher'
+    autoload :MockStream,  'cancer/spec/mock_stream'
+    autoload :Transcript,  'cancer/spec/transcript'
+    autoload :MockAdapter, 'cancer/spec/mock_adapter'
+    
+    class << self
+      attr_accessor :debug
+    end
+    
+    def dialog(&proc)
+      Cancer::Spec::MockAdapter.mock(&proc)
+    end
+    
+    def dialog_with(options={}, &proc)
+      Cancer::Spec::MockStream.mock do |adapter|
+        options = {:jid => 'alice@wonderland.lit', :password => 'ihatethequeen'}.merge(options)
+        options = options.merge(:adapter => adapter)
+        Cancer::Stream.open(options, &proc)
+      end
+    end
+    
+  end
+end

data/lib/cancer/spec/error.rb

@@ -0,0 +1,18 @@
+module Cancer
+  module Spec
+
+    class Error < ::Spec::Expectations::ExpectationNotMetError
+      attr_reader :error_message, :expectation_backtrace
+      def initialize(error_message, expectation_backtrace=nil)
+        @error_message, @expectation_backtrace = error_message, expectation_backtrace
+      end
+      def message
+        @error_message
+      end
+      def backtrace
+        @expectation_backtrace || super
+      end
+    end
+    
+  end
+end

data/lib/cancer/spec/extentions.rb

@@ -0,0 +1,79 @@
+
+module Spec
+  module Matchers
+    class RaiseError #:nodoc:
+      def matches?(given_proc)
+        @raised_expected_error = false
+        @with_expected_message = false
+        @eval_block = false
+        @eval_block_passed = false
+        begin
+          given_proc.call
+        rescue Spec::Expectations::ExpectationNotMetError => e
+          @eval_block_passed = true
+          @raised_expected_error = true
+          @with_expected_message = true
+          raise e
+          
+        rescue @expected_error => @actual_error
+          @raised_expected_error = true
+          @with_expected_message = verify_message
+        rescue Exception => @actual_error
+          # This clause should be empty, but rcov will not report it as covered
+          # unless something (anything) is executed within the clause
+          rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+        end
+
+        unless negative_expectation?
+          eval_block if @raised_expected_error && @with_expected_message && @block
+        end
+      ensure
+        return (@raised_expected_error & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+      end
+    end
+  end
+end
+
+module Nokogiri
+  module XML
+    class Node
+      def strip_empty_text!
+        if node_type == ELEMENT_NODE
+          self.children.each do |child|
+            child.strip_empty_text!
+          end
+        elsif node_type == TEXT_NODE
+          if to_s =~ /^[\s\n]+$/m
+            unlink
+          else
+            self.replace(Text.new(self.to_s.strip, self.document))
+          end
+        end
+        self
+      end
+      def matching?(other)
+        (self.node_type == other.node_type) and 
+        (
+          ( 
+            (self.node_type == ELEMENT_NODE) and 
+            (self.name == other.name) and
+            ((!!self.namespace) == (!!other.namespace)) and
+            (self.namespace ? (self.namespace.href == other.namespace.href) : true) and
+            (self.attributes.size == other.attributes.size) and
+            (self.attributes.inject(other.attributes) { |m, (x, n)|
+              m.delete(n.name) if m[n.name] and m[n.name].to_s == n.to_s; m  }.empty?) and 
+            (self.children.size == other.children.size) and
+            (self.children.inject(other.children.to_a) { |m, n| 
+              m.shift if n.matching? m.first ; m }.empty?)
+          ) or (
+            (self.node_type == TEXT_NODE) and 
+            (self.to_s == other.to_s)
+          ) or (
+            (self.node_type == CDATA_SECTION_NODE) and 
+            (self.to_s == other.to_s)
+          )
+        )
+      end
+    end
+  end
+end

data/lib/cancer/spec/matcher.rb

@@ -0,0 +1,30 @@
+module Cancer
+  module Spec
+
+    class Matcher
+      def initialize(transcript)
+        @transcript = transcript
+      end
+      def matches?(mock)
+        mock.transcript = @transcript.dup
+        mock.dialog.call(mock)
+        
+        if $cancer_error
+          raise $cancer_error 
+          $cancer_error = nil
+        end
+        return true
+      rescue ::Spec::Expectations::ExpectationNotMetError => e
+        @cancer_error ||= e
+        return false
+      end
+      def failure_message_for_should
+        @cancer_error.message
+      end
+      def failure_message_for_should_not
+        @cancer_error.message
+      end
+    end
+    
+  end
+end