messagebus_ruby_api 0.4.7 → 0.4.8

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/lib/rspec/expectations/errors.rb

@@ -1,12 +0,0 @@
-module RSpec
-  module Expectations
-    # If Test::Unit is loaed, we'll use its error as baseclass, so that Test::Unit
-    # will report unmet RSpec expectations as failures rather than errors.
-    superclass = ['Test::Unit::AssertionFailedError', '::StandardError'].map do |c|
-      eval(c) rescue nil
-    end.compact.first
-    
-    class ExpectationNotMetError < superclass
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/lib/rspec/expectations/extensions.rb

@@ -1,2 +0,0 @@
-require 'rspec/expectations/extensions/kernel'
-require 'rspec/expectations/extensions/array'

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/lib/rspec/expectations/extensions/array.rb

@@ -1,7 +0,0 @@
-class Array
-  unless public_instance_methods.map {|m| m.to_s}.include?('none?')
-    def none?(&block)
-      !any?(&block)
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/lib/rspec/expectations/extensions/kernel.rb

@@ -1,52 +0,0 @@
-module Kernel
-  # :call-seq:
-  #   should(matcher)
-  #   should == expected
-  #   should === expected
-  #   should =~ expected
-  #
-  #   receiver.should(matcher)
-  #     => Passes if matcher.matches?(receiver)
-  #
-  #   receiver.should == expected #any value
-  #     => Passes if (receiver == expected)
-  #
-  #   receiver.should === expected #any value
-  #     => Passes if (receiver === expected)
-  #
-  #   receiver.should =~ regexp
-  #     => Passes if (receiver =~ regexp)
-  #
-  # See RSpec::Matchers for more information about matchers
-  #
-  # == Warning
-  #
-  # NOTE that this does NOT support receiver.should != expected.
-  # Instead, use receiver.should_not == expected
-  def should(matcher=nil, message=nil, &block)
-    RSpec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block)
-  end
-  
-  # :call-seq:
-  #   should_not(matcher)
-  #   should_not == expected
-  #   should_not === expected
-  #   should_not =~ expected
-  #
-  #   receiver.should_not(matcher)
-  #     => Passes unless matcher.matches?(receiver)
-  #
-  #   receiver.should_not == expected
-  #     => Passes unless (receiver == expected)
-  #
-  #   receiver.should_not === expected
-  #     => Passes unless (receiver === expected)
-  #
-  #   receiver.should_not =~ regexp
-  #     => Passes unless (receiver =~ regexp)
-  #
-  # See RSpec::Matchers for more information about matchers
-  def should_not(matcher=nil, message=nil, &block)
-    RSpec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
-  end
-end

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/lib/rspec/expectations/fail_with.rb

@@ -1,51 +0,0 @@
-module RSpec
-  module Expectations
-    class << self
-      def differ
-        @differ ||= Differ.new
-      end
-      
-      # raises a RSpec::Expectations::ExpectationNotMetError with message
-      #
-      # When a differ has been assigned and fail_with is passed
-      # <code>expected</code> and <code>actual</code>, passes them
-      # to the differ to append a diff message to the failure message.
-      def fail_with(message, expected=nil, actual=nil) # :nodoc:
-        if !message
-          raise ArgumentError, "Failure message is nil. Does your matcher define the " +
-                               "appropriate failure_message_for_* method to return a string?"
-        end
-
-        if actual && expected
-          if all_strings?(actual, expected)
-            if any_multiline_strings?(actual, expected)
-              message << "\nDiff:" << self.differ.diff_as_string(actual, expected)
-            end
-          elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
-            message << "\nDiff:" << self.differ.diff_as_object(actual, expected)
-          end
-        end
-
-        raise(RSpec::Expectations::ExpectationNotMetError.new(message))
-      end
-
-    private
-
-      def no_procs?(*args)
-        args.none? {|a| Proc === a}
-      end
-
-      def all_strings?(*args)
-        args.all? {|a| String === a}
-      end
-
-      def any_multiline_strings?(*args)
-        all_strings?(*args) && args.any? {|a| a =~ /\n/}
-      end
-
-      def no_numbers?(*args)
-        args.none? {|a| Numeric === a}
-      end
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/lib/rspec/expectations/handler.rb

@@ -1,50 +0,0 @@
-module RSpec
-  module Expectations
-    class InvalidMatcherError < ArgumentError; end        
-    
-    class PositiveExpectationHandler        
-      def self.handle_matcher(actual, matcher, message=nil, &block)
-        ::RSpec::Matchers.last_should = :should
-        ::RSpec::Matchers.last_matcher = matcher
-        return ::RSpec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
-
-        match = matcher.matches?(actual, &block)
-        return match if match
-        
-        message ||= matcher.respond_to?(:failure_message_for_should) ?
-                    matcher.failure_message_for_should :
-                    matcher.failure_message
-        
-        if matcher.respond_to?(:diffable?) && matcher.diffable?
-          ::RSpec::Expectations.fail_with message, matcher.expected.first, matcher.actual
-        else
-          ::RSpec::Expectations.fail_with message
-        end
-      end
-    end
-
-    class NegativeExpectationHandler
-      def self.handle_matcher(actual, matcher, message=nil, &block)
-        ::RSpec::Matchers.last_should = :should_not
-        ::RSpec::Matchers.last_matcher = matcher
-        return ::RSpec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
-        
-        match = matcher.respond_to?(:does_not_match?) ?
-                !matcher.does_not_match?(actual, &block) :
-                matcher.matches?(actual, &block)
-        return match unless match
-        
-        message ||= matcher.respond_to?(:failure_message_for_should_not) ?
-                    matcher.failure_message_for_should_not :
-                    matcher.negative_failure_message
-
-        if matcher.respond_to?(:diffable?) && matcher.diffable?
-          ::RSpec::Expectations.fail_with message, matcher.expected.first, matcher.actual
-        else
-          ::RSpec::Expectations.fail_with message
-        end
-      end
-    end
-  end
-end
-

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/lib/rspec/expectations/version.rb

@@ -1,7 +0,0 @@
-module RSpec # :nodoc:
-  module Expectations # :nodoc:
-    module Version # :nodoc:
-      STRING = '2.5.0'
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/lib/rspec/matchers.rb

@@ -1,196 +0,0 @@
-module RSpec
-  # rspec-expecations provides a number of useful Matchers we use to compose
-  # expectations. A Matcher is any object that responds to the following
-  # methods:
-  #
-  #   matches?(actual)
-  #   failure_message_for_should
-  #
-  # These methods are also part of the matcher protocol, but are optional:
-  #
-  #   does_not_match?(actual)
-  #   failure_message_for_should_not
-  #   description #optional
-  #
-  # == Predicates
-  #
-  # In addition to those Expression Matchers that are defined explicitly, RSpec will
-  # create custom Matchers on the fly for any arbitrary predicate, giving your specs
-  # a much more natural language feel. 
-  #
-  # A Ruby predicate is a method that ends with a "?" and returns true or false.
-  # Common examples are +empty?+, +nil?+, and +instance_of?+.
-  #
-  # All you need to do is write +should be_+ followed by the predicate without
-  # the question mark, and RSpec will figure it out from there. For example:
-  #
-  #   [].should be_empty => [].empty? #passes
-  #   [].should_not be_empty => [].empty? #fails
-  #
-  # In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_"
-  # and "be_an_", making your specs read much more naturally:
-  #
-  #   "a string".should be_an_instance_of(String) =>"a string".instance_of?(String) #passes
-  #
-  #   3.should be_a_kind_of(Fixnum) => 3.kind_of?(Numeric) #passes
-  #   3.should be_a_kind_of(Numeric) => 3.kind_of?(Numeric) #passes
-  #   3.should be_an_instance_of(Fixnum) => 3.instance_of?(Fixnum) #passes
-  #   3.should_not be_instance_of(Numeric) => 3.instance_of?(Numeric) #fails
-  #
-  # RSpec will also create custom matchers for predicates like +has_key?+. To
-  # use this feature, just state that the object should have_key(:key) and RSpec will
-  # call has_key?(:key) on the target. For example:
-  #
-  #   {:a => "A"}.should have_key(:a) => {:a => "A"}.has_key?(:a) #passes
-  #   {:a => "A"}.should have_key(:b) => {:a => "A"}.has_key?(:b) #fails
-  #
-  # You can use this feature to invoke any predicate that begins with "has_", whether it is
-  # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
-  #
-  # == Custom Matchers
-  #
-  # When you find that none of the stock Expectation Matchers provide a natural
-  # feeling expectation, you can very easily write your own using RSpec's matcher
-  # DSL or writing one from scratch.
-  #
-  # === Matcher DSL
-  #
-  # Imagine that you are writing a game in which players can be in various
-  # zones on a virtual board. To specify that bob should be in zone 4, you
-  # could say:
-  #
-  #   bob.current_zone.should eql(Zone.new("4"))
-  #
-  # But you might find it more expressive to say:
-  #
-  #   bob.should be_in_zone("4")
-  #
-  # and/or
-  #
-  #   bob.should_not be_in_zone("3")
-  #
-  # You can create such a matcher like so:
-  #
-  #   RSpec::Matchers.define :be_in_zone do |zone|
-  #     match do |player|
-  #       player.in_zone?(zone)
-  #     end
-  #   end
-  #
-  # This will generate a <tt>be_in_zone</tt> method that returns a matcher
-  # with logical default messages for failures. You can override the failure
-  # messages and the generated description as follows:
-  #
-  #   RSpec::Matchers.define :be_in_zone do |zone|
-  #     match do |player|
-  #       player.in_zone?(zone)
-  #     end
-  #     failure_message_for_should do |player|
-  #       # generate and return the appropriate string.
-  #     end
-  #     failure_message_for_should_not do |player|
-  #       # generate and return the appropriate string.
-  #     end
-  #     description do
-  #       # generate and return the appropriate string.
-  #     end
-  #   end
-  #
-  # Each of the message-generation methods has access to the block arguments
-  # passed to the <tt>create</tt> method (in this case, <tt>zone</tt>). The
-  # failure message methods (<tt>failure_message_for_should</tt> and
-  # <tt>failure_message_for_should_not</tt>) are passed the actual value (the
-  # receiver of <tt>should</tt> or <tt>should_not</tt>).
-  #
-  # === Custom Matcher from scratch
-  #
-  # You could also write a custom matcher from scratch, as follows:
-  #
-  #   class BeInZone
-  #     def initialize(expected)
-  #       @expected = expected
-  #     end
-  #     def matches?(target)
-  #       @target = target
-  #       @target.current_zone.eql?(Zone.new(@expected))
-  #     end
-  #     def failure_message_for_should
-  #       "expected #{@target.inspect} to be in Zone #{@expected}"
-  #     end
-  #     def failure_message_for_should_not
-  #       "expected #{@target.inspect} not to be in Zone #{@expected}"
-  #     end
-  #   end
-  #
-  # ... and a method like this:
-  #
-  #   def be_in_zone(expected)
-  #     BeInZone.new(expected)
-  #   end
-  #
-  # And then expose the method to your specs. This is normally done
-  # by including the method and the class in a module, which is then
-  # included in your spec:
-  #
-  #   module CustomGameMatchers
-  #     class BeInZone
-  #       ...
-  #     end
-  #
-  #     def be_in_zone(expected)
-  #       ...
-  #     end
-  #   end
-  #
-  #   describe "Player behaviour" do
-  #     include CustomGameMatchers
-  #     ...
-  #   end
-  #
-  # or you can include in globally in a spec_helper.rb file <tt>require</tt>d
-  # from your spec file(s):
-  #
-  #   RSpec::Runner.configure do |config|
-  #     config.include(CustomGameMatchers)
-  #   end
-  #
-  module Matchers
-    # Include Matchers for other test frameworks
-    if defined?(Test::Unit::TestCase)
-      Test::Unit::TestCase.send(:include, self)
-    end
-    if defined?(MiniTest::Unit::TestCase)
-      MiniTest::Unit::TestCase.send(:include, self)
-    end
-  end
-end
-
-require 'rspec/matchers/extensions/instance_exec'
-require 'rspec/matchers/pretty'
-require 'rspec/matchers/matcher'
-require 'rspec/matchers/operator_matcher'
-require 'rspec/matchers/be'
-require 'rspec/matchers/be_close'
-require 'rspec/matchers/be_instance_of'
-require 'rspec/matchers/be_kind_of'
-require 'rspec/matchers/be_within'
-require 'rspec/matchers/block_aliases'
-require 'rspec/matchers/change'
-require 'rspec/matchers/eq'
-require 'rspec/matchers/eql'
-require 'rspec/matchers/equal'
-require 'rspec/matchers/errors'
-require 'rspec/matchers/exist'
-require 'rspec/matchers/generated_descriptions'
-require 'rspec/matchers/has'
-require 'rspec/matchers/have'
-require 'rspec/matchers/include'
-require 'rspec/matchers/match'
-require 'rspec/matchers/match_array'
-require 'rspec/matchers/method_missing'
-require 'rspec/matchers/raise_error'
-require 'rspec/matchers/respond_to'
-require 'rspec/matchers/satisfy'
-require 'rspec/matchers/throw_symbol'
-require 'rspec/matchers/compatibility'
-require 'rspec/matchers/dsl'

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/lib/rspec/matchers/be.rb

@@ -1,222 +0,0 @@
-require 'rspec/matchers/dsl'
-
-RSpec::Matchers.define :be_true do
-  match do |actual|
-    actual
-  end
-end
-
-RSpec::Matchers.define :be_false do
-  match do |actual|
-    !actual
-  end
-end
-
-RSpec::Matchers.define :be_nil do
-  match do |actual|
-    actual.nil?
-  end
-
-  failure_message_for_should do |actual|
-    "expected: nil\n     got: #{actual.inspect}"
-  end
-
-  failure_message_for_should_not do
-    "expected: not nil\n     got: nil"
-  end
-end
-
-module RSpec
-  module Matchers
-
-    class Be #:nodoc:
-      include RSpec::Matchers::Pretty
-      
-      def initialize(*args, &block)
-        @args = args
-      end
-      
-      def matches?(actual)
-        @actual = actual
-        !!@actual
-      end
-
-      def failure_message_for_should
-        "expected #{@actual.inspect} to evaluate to true"
-      end
-      
-      def failure_message_for_should_not
-        "expected #{@actual.inspect} to evaluate to false"
-      end
-      
-      def description
-        "be"
-      end
-
-      [:==, :<, :<=, :>=, :>, :===].each do |operator|
-        define_method operator do |operand|
-          BeComparedTo.new(operand, operator)
-        end
-      end
-
-    private
-
-      def args_to_s
-        @args.empty? ? "" : parenthesize(inspected_args.join(', '))
-      end
-      
-      def parenthesize(string)
-        "(#{string})"
-      end
-      
-      def inspected_args
-        @args.collect{|a| a.inspect}
-      end
-      
-      def expected_to_sentence
-        split_words(@expected)
-      end
-      
-      def args_to_sentence
-        to_sentence(@args)
-      end
-        
-    end
-
-    class BeComparedTo < Be
-
-      def initialize(operand, operator)
-        @expected, @operator = operand, operator
-        @args = []
-      end
-
-      def matches?(actual)
-        @actual = actual
-        @actual.__send__(@operator, @expected)
-      end
-
-      def failure_message_for_should
-        "expected: #{@operator} #{@expected.inspect}\n     got: #{@operator.to_s.gsub(/./, ' ')} #{@actual.inspect}"
-      end
-      
-      def failure_message_for_should_not
-        message = <<-MESSAGE
-'should_not be #{@operator} #{@expected}' not only FAILED,
-it is a bit confusing.
-          MESSAGE
-          
-        raise message << ([:===,:==].include?(@operator) ?
-          "It might be more clearly expressed without the \"be\"?" :
-          "It might be more clearly expressed in the positive?")
-      end
-
-      def description
-        "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
-      end
-
-    end
-
-    class BePredicate < Be
-
-      def initialize(*args, &block)
-        @expected = parse_expected(args.shift)
-        @args = args
-        @block = block
-      end
-      
-      def matches?(actual)
-        @actual = actual
-        begin
-          return @result = actual.__send__(predicate, *@args, &@block)
-        rescue NameError => predicate_missing_error
-          "this needs to be here or rcov will not count this branch even though it's executed in a code example"
-        end
-
-        begin
-          return @result = actual.__send__(present_tense_predicate, *@args, &@block)
-        rescue NameError
-          raise predicate_missing_error
-        end
-      end
-      
-      def failure_message_for_should
-        "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
-      end
-      
-      def failure_message_for_should_not
-        "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
-      end
-
-      def description
-        "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
-      end
-
-    private
-
-      def predicate
-        "#{@expected}?".to_sym
-      end
-      
-      def present_tense_predicate
-        "#{@expected}s?".to_sym
-      end
-      
-      def parse_expected(expected)
-        @prefix, expected = prefix_and_expected(expected)
-        expected
-      end
-
-      def prefix_and_expected(symbol)
-        symbol.to_s =~ /^(be_(an?_)?)(.*)/
-        return $1, $3
-      end
-
-      def prefix_to_sentence
-        split_words(@prefix)
-      end
-
-    end
-
-    # :call-seq:
-    #   should be_true
-    #   should be_false
-    #   should be_nil
-    #   should be_[arbitrary_predicate](*args)
-    #   should_not be_nil
-    #   should_not be_[arbitrary_predicate](*args)
-    #
-    # Given true, false, or nil, will pass if actual value is
-    # true, false or nil (respectively). Given no args means
-    # the caller should satisfy an if condition (to be or not to be). 
-    #
-    # Predicates are any Ruby method that ends in a "?" and returns true or false.
-    # Given be_ followed by arbitrary_predicate (without the "?"), RSpec will match
-    # convert that into a query against the target object.
-    #
-    # The arbitrary_predicate feature will handle any predicate
-    # prefixed with "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of)
-    # or "be_" (e.g. be_empty), letting you choose the prefix that best suits the predicate.
-    #
-    # == Examples 
-    #
-    #   target.should be_true
-    #   target.should be_false
-    #   target.should be_nil
-    #   target.should_not be_nil
-    #
-    #   collection.should be_empty #passes if target.empty?
-    #   target.should_not be_empty #passes unless target.empty?
-    #   target.should_not be_old_enough(16) #passes unless target.old_enough?(16)
-    def be(*args)
-      args.empty? ?
-        Matchers::Be.new : equal(*args)
-    end
-
-    # passes if target.kind_of?(klass)
-    def be_a(klass)
-      be_a_kind_of(klass)
-    end
-    
-    alias_method :be_an, :be_a
-  end
-end