messagebus_ruby_api 0.4.7 → 0.4.8

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

@@ -1,70 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,84 +0,0 @@
-### 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

@@ -1,42 +0,0 @@
-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

@@ -1,53 +0,0 @@
-# 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

@@ -1,135 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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"
-