messagebus_ruby_api 0.4.0 → 0.4.4

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

@@ -0,0 +1,19 @@
+module RSpec
+  module Matchers
+    module BlockAliases
+      alias_method :to,     :should
+      alias_method :to_not, :should_not
+      alias_method :not_to, :should_not
+    end
+
+    # Extends the submitted block with aliases to and to_not
+    # for should and should_not. Allows expectations like this:
+    #
+    #   expect { this_block }.to change{this.expression}.from(old_value).to(new_value)
+    #   expect { this_block }.to raise_error
+    def expect(&block)
+      block.extend BlockAliases
+    end
+  end
+end
+

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

@@ -0,0 +1,190 @@
+module RSpec
+  module Matchers
+    
+    #Based on patch from Wilson Bilkovich
+    class Change #:nodoc:
+      def initialize(receiver=nil, message=nil, &block)
+        @message = message
+        @value_proc = block || lambda {receiver.__send__(message)}
+        @to = @from = @minimum = @maximum = @amount = nil
+        @given_from = @given_to = false
+      end
+      
+      def matches?(event_proc)
+        raise_block_syntax_error if block_given?
+        
+        @before = evaluate_value_proc
+        event_proc.call
+        @after = evaluate_value_proc
+      
+        (!change_expected? || changed?) && matches_before? && matches_after? && matches_amount? && matches_min? && matches_max?
+      end
+
+      def raise_block_syntax_error
+        raise MatcherError.new(<<-MESSAGE
+block passed to should or should_not change must use {} instead of do/end
+MESSAGE
+        )
+      end
+      
+      def evaluate_value_proc
+        @value_proc.call
+      end
+      
+      def failure_message_for_should
+        if @given_from && @before != @from
+          "#{message} should have initially been #{@from.inspect}, but was #{@before.inspect}"
+        elsif @given_to && @to != @after
+          "#{message} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
+        elsif @amount
+          "#{message} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
+        elsif @minimum
+          "#{message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
+        elsif @maximum
+          "#{message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
+        else
+          "#{message} should have changed, but is still #{@before.inspect}"
+        end
+      end
+      
+      def actual_delta
+        @after - @before
+      end
+      
+      def failure_message_for_should_not
+        "#{message} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
+      end
+      
+      def by(amount)
+        @amount = amount
+        self
+      end
+      
+      def by_at_least(minimum)
+        @minimum = minimum
+        self
+      end
+      
+      def by_at_most(maximum)
+        @maximum = maximum
+        self
+      end      
+      
+      def to(to)
+        @given_to = true
+        @to = to
+        self
+      end
+      
+      def from (from)
+        @given_from = true
+        @from = from
+        self
+      end
+      
+      def description
+        "change ##{message}"
+      end
+
+    private
+      
+      def message
+        @message || "result"
+      end
+
+      def change_expected?
+        @amount != 0
+      end
+
+      def changed?
+        @before != @after
+      end
+
+      def matches_before?
+        @given_from ? @from == @before : true
+      end
+
+      def matches_after?
+        @given_to ? @to == @after : true
+      end
+
+      def matches_amount?
+        @amount ? (@before + @amount == @after) : true
+      end
+
+      def matches_min?
+        @minimum ? (@after - @before >= @minimum) : true
+      end
+
+      def matches_max?
+        @maximum ? (@after - @before <= @maximum) : true
+      end
+      
+    end
+    
+    # :call-seq:
+    #   should change(receiver, message)
+    #   should change(receiver, message).by(value)
+    #   should change(receiver, message).from(old).to(new)
+    #   should_not change(receiver, message)
+    #
+    #   should change {...}
+    #   should change {...}.by(value)
+    #   should change {...}.from(old).to(new)
+    #   should_not change {...}
+    #
+    # Applied to a proc, specifies that its execution will cause some value to
+    # change.
+    #
+    # You can either pass <tt>receiver</tt> and <tt>message</tt>, or a block,
+    # but not both.
+    #
+    # When passing a block, it must use the <tt>{ ... }</tt> format, not
+    # do/end, as <tt>{ ... }</tt> binds to the +change+ method, whereas do/end
+    # would errantly bind to the +should+ or +should_not+ method.
+    #
+    # == Examples
+    #
+    #   lambda {
+    #     team.add_player(player) 
+    #   }.should change(roster, :count)
+    #
+    #   lambda {
+    #     team.add_player(player) 
+    #   }.should change(roster, :count).by(1)
+    #
+    #   lambda {
+    #     team.add_player(player) 
+    #   }.should change(roster, :count).by_at_least(1)
+    #
+    #   lambda {
+    #     team.add_player(player)
+    #   }.should change(roster, :count).by_at_most(1)    
+    #
+    #   string = "string"
+    #   lambda {
+    #     string.reverse!
+    #   }.should change { string }.from("string").to("gnirts")
+    #
+    #   lambda {
+    #     person.happy_birthday
+    #   }.should change(person, :birthday).from(32).to(33)
+    #       
+    #   lambda {
+    #     employee.develop_great_new_social_networking_app
+    #   }.should change(employee, :title).from("Mail Clerk").to("CEO")
+    #
+    # == Notes
+    #
+    # Evaluates <tt>receiver.message</tt> or <tt>block</tt> before and after it
+    # evaluates the proc object (generated by the lambdas in the examples
+    # above).
+    #
+    # <tt>should_not change</tt> only supports the form with no subsequent
+    # calls to <tt>by</tt>, <tt>by_at_least</tt>, <tt>by_at_most</tt>,
+    # <tt>to</tt> or <tt>from</tt>.
+    def change(receiver=nil, message=nil, &block)
+      Matchers::Change.new(receiver, message, &block)
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+RSpec::Matchers.constants.each do |c|
+  if Class === (klass = RSpec::Matchers.const_get(c))
+    if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)}
+      klass.class_eval do
+        alias_method :failure_message, :failure_message_for_should
+      end
+    end
+    if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)}
+      klass.class_eval do
+        alias_method :negative_failure_message, :failure_message_for_should_not
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module RSpec
+  module Matchers
+    module DSL
+      # See RSpec::Matchers
+      def define(name, &declarations)
+        define_method name do |*expected|
+          $matcher_execution_context = self
+          RSpec::Matchers::Matcher.new name, *expected, &declarations
+        end
+      end
+
+      alias_method :matcher, :define
+
+      if RSpec.respond_to?(:configure)
+        RSpec.configure {|c| c.extend self}
+      end
+    end
+  end
+end
+
+RSpec::Matchers.extend RSpec::Matchers::DSL

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

@@ -0,0 +1,50 @@
+module RSpec
+  module Matchers
+    # :call-seq:
+    #   should eq(expected)
+    #   should_not eq(expected)
+    #
+    # Passes if actual == expected.
+    #
+    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
+    #
+    # == Examples
+    #
+    #   5.should eq(5)
+    #   5.should_not eq(3)
+    def eq(expected)
+      Matcher.new :eq, expected do |_expected_|
+
+        diffable
+
+        match do |actual|
+          actual == _expected_
+        end
+
+        failure_message_for_should do |actual|
+          <<-MESSAGE
+
+expected #{_expected_.inspect}
+     got #{actual.inspect}
+
+(compared using ==)
+MESSAGE
+        end
+
+        failure_message_for_should_not do |actual|
+          <<-MESSAGE
+
+expected #{actual.inspect} not to equal #{_expected_.inspect}
+
+(compared using ==)
+MESSAGE
+        end
+
+        description do
+          "== #{_expected_}"
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,45 @@
+module RSpec
+  module Matchers
+    # :call-seq:
+    #   should eql(expected)
+    #   should_not eql(expected)
+    #
+    # Passes if actual and expected are of equal value, but not necessarily the same object.
+    #
+    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
+    #
+    # == Examples
+    #
+    #   5.should eql(5)
+    #   5.should_not eql(3)
+    def eql(expected)
+      Matcher.new :eql, expected do |_expected_|
+
+        diffable
+
+        match do |actual|
+          actual.eql?(_expected_)
+        end
+
+        failure_message_for_should do |actual|
+          <<-MESSAGE
+
+expected #{_expected_.inspect}
+     got #{actual.inspect}
+
+(compared using eql?)
+MESSAGE
+        end
+
+        failure_message_for_should_not do |actual|
+          <<-MESSAGE
+
+expected #{actual.inspect} not to equal #{_expected_.inspect}
+
+(compared using eql?)
+MESSAGE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module RSpec
+  module Matchers
+
+    # :call-seq:
+    #   should equal(expected)
+    #   should_not equal(expected)
+    #
+    # Passes if actual and expected are the same object (object identity).
+    #
+    # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
+    #
+    # == Examples
+    #
+    #   5.should equal(5) #Fixnums are equal
+    #   "5".should_not equal("5") #Strings that look the same are not the same object
+    def equal(expected)
+      Matcher.new :equal, expected do |_expected_|
+        match do |actual|
+          actual.equal?(_expected_)
+        end
+        
+        def inspect_object(o)
+          "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
+        end
+        
+        failure_message_for_should do |actual|
+          <<-MESSAGE
+
+expected #{inspect_object(_expected_)}
+     got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity,
+but expected and actual are not the same object. Use
+'actual.should == expected' if you don't care about
+object identity in this example.
+
+MESSAGE
+        end
+
+        failure_message_for_should_not do |actual|
+          <<-MESSAGE
+
+expected not #{inspect_object(actual)}
+         got #{inspect_object(_expected_)}
+
+Compared using equal?, which compares object identity.
+
+MESSAGE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module RSpec
+  module Matchers
+    class MatcherError < StandardError; end
+  end
+end

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

@@ -0,0 +1,26 @@
+module RSpec
+  module Matchers
+    # :call-seq:
+    #   should exist
+    #   should_not exist
+    #
+    # Passes if actual.exist? or actual.exists?
+    def exist(*args)
+      Matcher.new :exist do
+        match do |actual|
+          predicates = [:exist?, :exists?].select { |p| actual.respond_to?(p) }
+          existance_values = predicates.map { |p| actual.send(p, *args) }
+          uniq_truthy_values = existance_values.map { |v| !!v }.uniq
+
+          case uniq_truthy_values.size
+            when 0; raise NoMethodError.new("#{actual.inspect} does not respond to either #exist? or #exists?")
+            when 1; existance_values.first
+            else raise "#exist? and #exists? returned different values:\n\n" +
+                       " exist?: #{existance_values.first}\n" +
+                       "exists?: #{existance_values.last}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module RSpec
+  module Matchers
+    module InstanceExec
+      unless respond_to?(:instance_exec)
+        # based on Bounded Spec InstanceExec (Mauricio Fernandez)
+        # http://eigenclass.org/hiki/bounded+space+instance_exec
+        # - uses singleton_class of matcher instead of global
+        #   InstanceExecHelper module
+        # - this keeps it scoped to this class only, which is the
+        #   only place we need it
+        # - only necessary for ruby 1.8.6
+        def instance_exec(*args, &block)
+          singleton_class = (class << self; self; end)
+          begin
+            orig_critical, Thread.critical = Thread.critical, true
+            n = 0
+            n += 1 while respond_to?(method_name="__instance_exec#{n}")
+            singleton_class.module_eval{ define_method(method_name, &block) }
+          ensure
+            Thread.critical = orig_critical
+          end
+          begin
+            return send(method_name, *args)
+          ensure
+            singleton_class.module_eval{ remove_method(method_name) } rescue nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module RSpec
+  module Matchers
+    class << self
+      attr_accessor :last_matcher, :last_should # :nodoc:
+    end
+
+    def self.clear_generated_description
+      self.last_matcher = nil
+      self.last_should = nil
+    end
+
+    def self.generated_description
+      return nil if last_should.nil?
+      "#{last_should.to_s.gsub('_',' ')} #{last_description}"
+    end
+    
+  private
+    
+    def self.last_description
+      last_matcher.respond_to?(:description) ? last_matcher.description : <<-MESSAGE
+When you call a matcher in an example without a String, like this:
+
+specify { object.should matcher }
+
+or this:
+
+it { should matcher }
+
+RSpec expects the matcher to have a #description method. You should either
+add a String to the example this matcher is being used in, or give it a
+description method. Then you won't have to suffer this lengthy warning again.
+MESSAGE
+    end
+  end
+end
+      

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

@@ -0,0 +1,35 @@
+module RSpec
+  module Matchers
+    
+    class Has
+      
+      def initialize(expected, *args)
+        @expected, @args = expected, args
+      end
+      
+      def matches?(actual)
+        actual.__send__(predicate(@expected), *@args)
+      end
+      
+      def failure_message_for_should
+        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return true, got false"
+      end
+      
+      def failure_message_for_should_not
+        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return false, got true"
+      end
+      
+      def description
+        "have key #{@args[0].inspect}"
+      end
+    
+    private
+    
+      def predicate(sym)
+        "#{sym.to_s.sub("have_","has_")}?".to_sym
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,151 @@
+module RSpec
+  module Matchers
+    class Have #:nodoc:
+      def initialize(expected, relativity=:exactly)
+        @expected = (expected == :no ? 0 : expected)
+        @relativity = relativity
+        @actual = @collection_name = @plural_collection_name = nil
+      end
+    
+      def relativities
+        @relativities ||= {
+          :exactly => "",
+          :at_least => "at least ",
+          :at_most => "at most "
+        }
+      end
+    
+      def matches?(collection_owner)
+        if collection_owner.respond_to?(@collection_name)
+          collection = collection_owner.__send__(@collection_name, *@args, &@block)
+        elsif (@plural_collection_name && collection_owner.respond_to?(@plural_collection_name))
+          collection = collection_owner.__send__(@plural_collection_name, *@args, &@block)
+        elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size))
+          collection = collection_owner
+        else
+          collection_owner.__send__(@collection_name, *@args, &@block)
+        end
+        @actual = collection.size if collection.respond_to?(:size)
+        @actual = collection.length if collection.respond_to?(:length)
+        raise not_a_collection if @actual.nil?
+        return @actual >= @expected if @relativity == :at_least
+        return @actual <= @expected if @relativity == :at_most
+        return @actual == @expected
+      end
+      
+      def not_a_collection
+        "expected #{@collection_name} to be a collection but it does not respond to #length or #size"
+      end
+    
+      def failure_message_for_should
+        "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
+      end
+
+      def failure_message_for_should_not
+        if @relativity == :exactly
+          return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
+        elsif @relativity == :at_most
+          return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_most(#{@expected}).#{@collection_name}
+We recommend that you use this instead:
+  should have_at_least(#{@expected + 1}).#{@collection_name}
+EOF
+        elsif @relativity == :at_least
+          return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_least(#{@expected}).#{@collection_name}
+We recommend that you use this instead:
+  should have_at_most(#{@expected - 1}).#{@collection_name}
+EOF
+        end
+      end
+      
+      def description
+        "have #{relative_expectation} #{@collection_name}"
+      end
+      
+      def respond_to?(sym)
+        @expected.respond_to?(sym) || super
+      end
+    
+      private
+      
+      def method_missing(method, *args, &block)
+        @collection_name = method
+        if inflector = (defined?(ActiveSupport::Inflector) && ActiveSupport::Inflector.respond_to?(:pluralize) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
+          @plural_collection_name = inflector.pluralize(method.to_s)
+        end
+        @args = args
+        @block = block
+        self
+      end
+      
+      def relative_expectation
+        "#{relativities[@relativity]}#{@expected}"
+      end
+    end
+
+    # :call-seq:
+    #   should have(number).named_collection__or__sugar
+    #   should_not have(number).named_collection__or__sugar
+    #
+    # Passes if receiver is a collection with the submitted
+    # number of items OR if the receiver OWNS a collection
+    # with the submitted number of items.
+    #
+    # If the receiver OWNS the collection, you must use the name
+    # of the collection. So if a <tt>Team</tt> instance has a
+    # collection named <tt>#players</tt>, you must use that name
+    # to set the expectation.
+    #
+    # If the receiver IS the collection, you can use any name
+    # you like for <tt>named_collection</tt>. We'd recommend using
+    # either "elements", "members", or "items" as these are all
+    # standard ways of describing the things IN a collection.
+    #
+    # This also works for Strings, letting you set an expectation
+    # about its length
+    #
+    # == Examples
+    #
+    #   # Passes if team.players.size == 11
+    #   team.should have(11).players
+    #
+    #   # Passes if [1,2,3].length == 3
+    #   [1,2,3].should have(3).items #"items" is pure sugar
+    #
+    #   # Passes if "this string".length == 11
+    #   "this string".should have(11).characters #"characters" is pure sugar
+    def have(n)
+      Matchers::Have.new(n)
+    end
+    alias :have_exactly :have
+
+    # :call-seq:
+    #   should have_at_least(number).items
+    #
+    # Exactly like have() with >=.
+    #
+    # == Warning
+    #
+    # +should_not+ +have_at_least+ is not supported
+    def have_at_least(n)
+      Matchers::Have.new(n, :at_least)
+    end
+
+    # :call-seq:
+    #   should have_at_most(number).items
+    #
+    # Exactly like have() with <=.
+    #
+    # == Warning
+    #
+    # +should_not+ +have_at_most+ is not supported
+    def have_at_most(n)
+      Matchers::Have.new(n, :at_most)
+    end
+  end
+end