messagebus_ruby_api 0.4.0 → 0.4.4

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/Gemfile

@@ -0,0 +1,38 @@
+source "http://rubygems.org"
+
+### rspec libs
+%w[rspec-core rspec-expectations rspec-mocks].each do |lib|
+  library_path = File.expand_path("../../#{lib}", __FILE__)
+  if File.exist?(library_path)
+    gem lib, :path => library_path
+  else
+    gem lib
+  end
+end
+
+### dev dependencies
+gem "rake", "0.8.7"
+gem "cucumber", "0.9.4"
+gem "aruba", "0.2.2"
+gem "rcov", "0.9.9"
+gem "relish", "0.2.0"
+gem "guard-rspec", "0.1.9"
+gem "growl", "1.0.3"
+gem "ZenTest", "~> 4.4.2"
+
+if RUBY_PLATFORM =~ /darwin/
+  gem "autotest-fsevent", "~> 0.2.4"
+  gem "autotest-growl", "~> 0.2.9"
+end
+
+gem "ruby-debug", :platforms => :ruby_18
+gem "ruby-debug19", "~> 0.11.6", :platforms => :ruby_19
+
+platforms :ruby_18, :ruby_19 do
+  gem "rb-fsevent", "~> 0.3.9"
+  gem "ruby-prof", "~> 0.9.2"
+end
+
+platforms :jruby do
+  gem "jruby-openssl"
+end

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :version => 2 do
+  watch(/^spec\/(.*)_spec.rb/)
+  watch(/^lib\/(.*)\.rb/)         { |m| "spec/#{m[1]}_spec.rb" }
+  watch(/^spec\/spec_helper.rb/)  { "spec" }
+end

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/License.txt

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2005 The RSpec Development Team
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/README.md

@@ -0,0 +1,41 @@
+# RSpec Expectations
+
+rspec-expectations adds `should` and `should_not` to every object and includes
+RSpec::Matchers, a library of standard matchers.
+
+## Documentation
+
+The [Cucumber features](http://relishapp.com/rspec/rspec-expectations)
+are the most comprehensive and up-to-date docs for end-users.
+
+The [RDoc](http://rubydoc.info/gems/rspec-expectations/2.3.0/frames) provides
+additional information for contributors and/or extenders.
+
+All of the documentation is open source and a work in progress. If you find it
+lacking or confusing, you can help improve it by submitting requests and
+patches to the [rspec-expectations issue
+tracker](https://github.com/rspec/rspec-expectations/issues).
+
+## Install
+
+    gem install rspec               # for rspec-core, rspec-expectations, rspec-mocks
+    gem install rspec-expecctations # for rspec-expectations only
+
+## Matchers
+
+Matchers are objects used to compose expectations:
+
+    result.should eq("this value")
+
+In that example, `eq("this value")` returns a `Matcher` object that
+compares the actual `result` to the expected `"this value"`.
+
+## Contribute
+
+See [http://github.com/rspec/rspec-dev](http://github.com/rspec/rspec-dev)
+
+## Also see
+
+* [http://github.com/rspec/rspec](http://github.com/rspec/rspec)
+* [http://github.com/rspec/rspec-core](http://github.com/rspec/rspec-core)
+* [http://github.com/rspec/rspec-mocks](http://github.com/rspec/rspec-mocks)

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/Rakefile

@@ -0,0 +1,70 @@
+require 'bundler'
+Bundler.setup
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
+require 'rspec/expectations/version'
+require 'cucumber/rake/task'
+
+class Cucumber::Rake::Task::ForkedCucumberRunner
+  # When cucumber shells out, we still need it to run in the context of our
+  # bundle.
+  def run
+    sh "bundle exec #{RUBY} " + args.join(" ")
+  end
+end
+
+task :cleanup_rcov_files do
+  rm_rf 'coverage.data'
+end
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color]
+end
+
+Cucumber::Rake::Task.new(:cucumber)
+
+namespace :spec do
+  desc "Run all examples using rcov"
+  RSpec::Core::RakeTask.new :rcov => :cleanup_rcov_files do |t|
+    t.rcov = true
+    t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
+    t.rcov_opts << %[--text-report --sort coverage --no-html --aggregate coverage.data]
+  end
+end
+
+namespace :cucumber do
+  desc "Run cucumber features using rcov"
+  Cucumber::Rake::Task.new :rcov => :cleanup_rcov_files do |t|
+    t.cucumber_opts = %w{--format progress}
+    t.rcov = true
+    t.rcov_opts =  %[-Ilib -Ispec --exclude "gems/*,features"]
+    t.rcov_opts << %[--text-report --sort coverage --aggregate coverage.data]
+  end
+end
+
+task :default => [:spec, :cucumber]
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rspec-expectations #{RSpec::Expectations::Version::STRING}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Push docs/cukes to relishapp using the relish-client-gem"
+task :relish, :version do |t, args|
+  raise "rake relish[VERSION]" unless args[:version]
+  sh "relish push rspec/rspec-expectations:#{args[:version]}"
+end
+
+task :clobber do
+  rm_rf 'doc'
+  rm_rf 'pkg'
+  rm_rf 'tmp'
+  rm_rf 'coverage'
+end
+

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/cucumber.yml

@@ -0,0 +1,3 @@
+default: --require features --tags ~@wip --format progress
+wip: --require features --tags @wip:3 --wip features
+

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/Changelog.md

@@ -0,0 +1,84 @@
+### 2.5.0 / 2011-02-05
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.4.0...v2.5.0)
+
+* Enhancements
+  * `should exist` works with `exist?` or `exists?` (Myron Marston)
+  * `expect { ... }.not_to do_something` (in addition to `to_not`)
+
+* Documentation
+  * improved docs for raise_error matcher (James Almond)
+
+### 2.4.0 / 2011-01-02
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.3.0...v2.4.0)
+
+No functional changes in this release, which was made to align with the
+rspec-core-2.4.0 release.
+
+* Enhancements
+  * improved RDoc for change matcher (Jo Liss)
+
+### 2.3.0 / 2010-12-12
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.2.1...v2.3.0)
+
+* Enhancements
+  * diff strings when include matcher fails (Mike Sassak)
+
+### 2.2.0 / 2010-11-28
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.1.0...v2.2.0)
+
+### 2.1.0 / 2010-11-07
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.1...v2.1.0)
+
+* Enhancements
+  * be_within(delta).of(expected) matcher (Myron Marston)
+  * Lots of new Cucumber features (Myron Marston)
+  * Raise error if you try "should != expected" on Ruby-1.9 (Myron Marston)
+  * Improved failure messages from throw_symbol (Myron Marston)
+
+* Bug fixes
+  * Eliminate hard dependency on RSpec::Core (Myron Marston)
+  * have_matcher - use pluralize only when ActiveSupport inflections are indeed
+    defined (Josep M Bach)
+  * throw_symbol matcher no longer swallows exceptions (Myron Marston)
+  * fix matcher chaining to avoid name collisions (Myron Marston)
+
+### 2.0.0 / 2010-10-10
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.rc...v2.0.0)
+
+* Enhancements
+  * Add match_for_should_not method to matcher DSL (Myron Marston)
+
+* Bug fixes
+  * respond_to matcher works correctly with should_not with multiple methods (Myron Marston)
+  * include matcher works correctly with should_not with multiple values (Myron Marston)
+
+### 2.0.0.rc / 2010-10-05
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.beta.22...v2.0.0.rc)
+
+* Enhancements
+  * require 'rspec/expectations' in a T::U or MiniUnit suite (Josep M. Bach)
+
+* Bug fixes
+  * change by 0 passes/fails correctly (Len Smith)
+  * Add description to satisfy matcher
+
+### 2.0.0.beta.22 / 2010-09-12
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.beta.20...v2.0.0.beta.22)
+
+* Enhancements
+  * diffing improvements
+    * diff multiline strings
+    * don't diff single line strings
+    * don't diff numbers (silly)
+    * diff regexp + multiline string
+
+* Bug fixes
+  * should[_not] change now handles boolean values correctly

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/README.markdown

@@ -0,0 +1,42 @@
+rspec-expectations is used to set expectations in executable examples.
+
+    describe Account do
+      it "has a balance of zero when first created" do
+        Account.new.balance.should eq(Money.new(0))
+      end
+    end
+
+## should and should_not
+
+rspec-expectations adds `should` and `should_not` to every object. Each of
+these can accept a matcher and, in most cases, an optional custom failure
+message (see [customized
+message](/rspec/rspec-expectations/v/2-3/customized-message)).
+
+## Matchers
+
+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
+
+RSpec ships with a number of [built-in
+matchers](/rspec/rspec-expectations/v/2-3/dir/built-in-matchers) and a DSL for
+writing your own [custom
+matchers](/rspec/rspec-expectations/v/2-3/dir/custom-matchers).
+
+## Issues
+
+The documentation for rspec-expectations is a work in progress. We'll be adding
+Cucumber features over time, and clarifying existing ones.  If you have
+specific features you'd like to see added, find the existing documentation
+incomplete or confusing, or, better yet, wish to write a missing Cucumber
+feature yourself, please [submit an
+issue](http://github.com/rspec/rspec-expectations/issues) or a [pull
+request](http://github.com/rspec/rspec-expectations).

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/Upgrade.md

@@ -0,0 +1,53 @@
+# Upgrade to rspec-expectations-2.0
+
+## What's new
+
+### New `eq` matcher.
+
+`RSpec::Matchers` now offers you two approaches to differentiating between
+object identity. You can use the rspec-1 approach:
+
+    actual.should == expected     # object equality
+    actual.should equal(expected) # object identity
+
+... or, if you prefer:
+
+    actual.should eq(expected) # object equality
+    actual.should be(expected) # object identity
+
+## What's been removed
+
+### simple_matcher
+
+Use RSpec::Matchers.define instead. For example, if you had:
+
+    def eat_cheese
+      simple_matcher("eat cheese") do |actual|
+        actual.eat?(:cheese)
+      end
+    end
+
+Change it to:
+
+    RSpec::Matchers.define :eat_cheese do
+      match do |actual|
+        actual.eat?(:cheese)
+      end
+    end
+
+### wrap_expectation
+
+Use RSpec::Matchers.define instead.
+
+    RSpec::Matchers.define :eat_cheese do
+      match do |actual|
+        actual.should eat?(:cheese)
+      end
+    end
+
+    RSpec::Matchers.define :eat_cheese do
+      include MyCheesyAssertions
+      match_unless_raises Test::Unit::AssertionFailedError do |actual|
+        assert_eats_chesse actual
+      end
+    end

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/built_in_matchers/be.feature

@@ -0,0 +1,135 @@
+Feature: "be" matchers
+
+  There are several related "be" matchers:
+
+      obj.should be_true  # passes if obj is truthy (not nil or false)
+      obj.should be_false # passes if obj is falsy (nil or false)
+      obj.should be_nil   # passes if obj is nil
+      obj.should be       # passes if obj is not nil
+
+  Scenario: be_true matcher
+    Given a file named "be_true_spec.rb" with:
+      """
+      describe "be_true matcher" do
+        specify { true.should be_true }
+        specify { 7.should be_true }
+        specify { "foo".should be_true }
+        specify { nil.should_not be_true }
+        specify { false.should_not be_true }
+
+        # deliberate failures
+        specify { true.should_not be_true }
+        specify { 7.should_not be_true }
+        specify { "foo".should_not be_true }
+        specify { nil.should be_true }
+        specify { false.should be_true }
+      end
+      """
+    When I run "rspec be_true_spec.rb"
+    Then the output should contain all of these:
+      | 10 examples, 5 failures       |
+      | expected true not to be true  |
+      | expected 7 not to be true     |
+      | expected "foo" not to be true |
+      | expected nil to be true       |
+      | expected false to be true     |
+
+  Scenario: be_false matcher
+    Given a file named "be_false_spec.rb" with:
+      """
+      describe "be_false matcher" do
+        specify { nil.should be_false }
+        specify { false.should be_false }
+        specify { true.should_not be_false }
+        specify { 7.should_not be_false }
+        specify { "foo".should_not be_false }
+
+        # deliberate failures
+        specify { nil.should_not be_false }
+        specify { false.should_not be_false }
+        specify { true.should be_false }
+        specify { 7.should be_false }
+        specify { "foo".should be_false }
+      end
+      """
+    When I run "rspec be_false_spec.rb"
+    Then the output should contain all of these:
+      | 10 examples, 5 failures        |
+      | expected nil not to be false   |
+      | expected false not to be false |
+      | expected true to be false      |
+      | expected 7 to be false         |
+      | expected "foo" to be false     |
+
+  Scenario: be_nil matcher
+    Given a file named "be_nil_spec.rb" with:
+      """
+      describe "be_nil matcher" do
+        specify { nil.should be_nil }
+        specify { false.should_not be_nil }
+        specify { true.should_not be_nil }
+        specify { 7.should_not be_nil }
+        specify { "foo".should_not be_nil }
+
+        # deliberate failures
+        specify { nil.should_not be_nil }
+        specify { false.should be_nil }
+        specify { true.should be_nil }
+        specify { 7.should be_nil }
+        specify { "foo".should be_nil }
+      end
+      """
+    When I run "rspec be_nil_spec.rb"
+    Then the output should contain "10 examples, 5 failures"
+    And the output should contain:
+      """
+             expected: not nil
+                  got: nil
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: false
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: true
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: 7
+      """
+    And the output should contain:
+      """
+             expected: nil
+                  got: "foo"
+      """
+
+  Scenario: be matcher
+    Given a file named "be_spec.rb" with:
+      """
+      describe "be_matcher" do
+        specify { true.should be }
+        specify { 7.should be }
+        specify { "foo".should be }
+        specify { nil.should_not be }
+        specify { false.should_not be }
+
+        # deliberate failures
+        specify { true.should_not be }
+        specify { 7.should_not be }
+        specify { "foo".should_not be }
+        specify { nil.should be }
+        specify { false.should be }
+      end
+      """
+    When I run "rspec be_spec.rb"
+    Then the output should contain all of these:
+      | 10 examples, 5 failures             |
+      | expected true to evaluate to false  |
+      | expected 7 to evaluate to false     |
+      | expected "foo" to evaluate to false |
+      | expected nil to evaluate to true    |
+      | expected false to evaluate to true  |

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/built_in_matchers/be_within.feature

@@ -0,0 +1,43 @@
+Feature: be_within matcher
+
+  Normal equality expectations do not work well for floating point values.
+  Consider this irb session:
+
+    > radius = 3
+      => 3 
+    > area_of_circle = radius * radius * Math::PI
+      => 28.2743338823081 
+    > area_of_circle == 28.2743338823081
+      => false 
+
+  Instead, you should use the be_within matcher to check that the value
+  is within a delta of your expected value:
+
+    area_of_circle.should be_within(0.1).of(28.3)
+
+  Note that the difference between the actual and expected values must be
+  smaller than your delta; if it is equal, the matcher will fail.
+
+  Scenario: basic usage
+    Given a file named "be_within_matcher_spec.rb" with:
+      """
+      describe 27.5 do
+        it { should be_within(0.5).of(27.9) }
+        it { should be_within(0.5).of(27.1) }
+        it { should_not be_within(0.5).of(28) }
+        it { should_not be_within(0.5).of(27) }
+
+        # deliberate failures
+        it { should_not be_within(0.5).of(27.9) }
+        it { should_not be_within(0.5).of(27.1) }
+        it { should be_within(0.5).of(28) }
+        it { should be_within(0.5).of(27) }
+      end
+      """
+    When I run "rspec be_within_matcher_spec.rb"
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                     |
+      | expected 27.5 not to be within 0.5 of 27.9 |
+      | expected 27.5 not to be within 0.5 of 27.1 |
+      | expected 27.5 to be within 0.5 of 28       |
+      | expected 27.5 to be within 0.5 of 27       |

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/built_in_matchers/equality.feature

@@ -0,0 +1,142 @@
+Feature: equality matchers
+
+  Ruby exposes several different methods for handling equality:
+
+    a.equal?(b) # object identity - a and b refer to the same object
+    a.eql?(b)   # object equivalence - a and b have the same value
+    a == b      # object equivalence - a and b have the same value with type conversions
+
+  Note that these descriptions are guidelines but are not forced by the
+  language. Any object can implement any of these methods with its own
+  semantics.
+
+  rspec-expectations ships with matchers that align with each of these methods:
+
+    a.should equal(b) # passes if a.equal?(b)
+    a.should eql(b)   # passes if a.eql?(b)
+    a.should == b     # passes if a == b
+
+  It also ships with two matchers that have more of a DSL feel to them:
+
+    a.should be(b) # passes if a.equal?(b)
+    a.should eq(b) # passes if a == b
+
+  Scenario: compare using eq (==)
+    Given a file named "compare_using_eq.rb" with:
+      """
+      require 'spec_helper'
+
+      describe "a string" do
+        it "is equal to another string of the same value" do
+          "this string".should eq("this string")
+        end
+
+        it "is not equal to another string of a different value" do
+          "this string".should_not eq("a different string")
+        end
+      end
+
+      describe "an integer" do
+        it "is equal to a float of the same value" do
+          5.should eq(5.0)
+        end
+      end
+      """
+    When I run "rspec compare_using_eq.rb"
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using ==
+    Given a file named "compare_using_==.rb" with:
+      """
+      require 'spec_helper'
+
+      describe "a string" do
+        it "is equal to another string of the same value" do
+          "this string".should == "this string"
+        end
+
+        it "is not equal to another string of a different value" do
+          "this string".should_not == "a different string"
+        end
+      end
+
+      describe "an integer" do
+        it "is equal to a float of the same value" do
+          5.should == 5.0
+        end
+      end
+      """
+    When I run "rspec compare_using_==.rb"
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using eql (eql?)
+    Given a file named "compare_using_eql.rb" with:
+      """
+      require 'spec_helper'
+
+      describe "an integer" do
+        it "is equal to another integer of the same value" do
+          5.should eql(5)
+        end
+
+        it "is not equal to another integer of a different value" do
+          5.should_not eql(6)
+        end
+
+        it "is not equal to a float of the same value" do
+          5.should_not eql(5.0)
+        end
+
+      end
+      """
+    When I run "rspec compare_using_eql.rb"
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using equal (equal?)
+    Given a file named "compare_using_equal.rb" with:
+      """
+      require 'spec_helper'
+
+      describe "a string" do
+        it "is equal to itself" do
+          string = "this string"
+          string.should equal(string)
+        end
+
+        it "is not equal to another string of the same value" do
+          "this string".should_not equal("this string")
+        end
+
+        it "is not equal to another string of a different value" do
+          "this string".should_not equal("a different string")
+        end
+
+      end
+      """
+    When I run "rspec compare_using_equal.rb"
+    Then the output should contain "3 examples, 0 failures"
+
+  Scenario: compare using be (equal?)
+    Given a file named "compare_using_be.rb" with:
+      """
+      require 'spec_helper'
+
+      describe "a string" do
+        it "is equal to itself" do
+          string = "this string"
+          string.should be(string)
+        end
+
+        it "is not equal to another string of the same value" do
+          "this string".should_not be("this string")
+        end
+
+        it "is not equal to another string of a different value" do
+          "this string".should_not be("a different string")
+        end
+
+      end
+      """
+    When I run "rspec compare_using_be.rb"
+    Then the output should contain "3 examples, 0 failures"
+