messagebus_ruby_api 0.4.7 → 0.4.8

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

@@ -1,85 +0,0 @@
-Feature: throw_symbol matcher
-
-  The throw_symbol matcher is used to specify that a block of code
-  throws a symbol.  The most basic form passes if any symbol is thrown:
-
-    expect { throw :foo }.to throw_symbol
-
-  You'll often want to specify that a particular symbol is thrown:
-
-    expect { throw :foo }.to throw_symbol(:foo)
-
-  If you care about the additional argument given to throw, you can
-  specify that as well:
-
-    expect { throw :foo, 7 }.to throw_symbol(:foo, 7)
-
-  Scenario: basic usage
-    Given a file named "throw_symbol_matcher_spec.rb" with:
-      """
-      describe "throw" do
-        specify { expect { throw :foo    }.to     throw_symbol }
-        specify { expect { throw :bar, 7 }.to     throw_symbol }
-        specify { expect { 5 + 5         }.to_not throw_symbol }
-
-        # deliberate failures
-        specify { expect { throw :foo    }.to_not throw_symbol }
-        specify { expect { throw :bar, 7 }.to_not throw_symbol }
-        specify { expect { 5 + 5         }.to     throw_symbol }
-      end
-      """
-    When I run "rspec throw_symbol_matcher_spec.rb"
-    Then the output should contain all of these:
-      | 6 examples, 3 failures                      |
-      | expected no Symbol to be thrown, got :foo   |
-      | expected no Symbol to be thrown, got :bar   |
-      | expected a Symbol to be thrown, got nothing |
-
-  Scenario: specify thrown symbol
-    Given a file named "throw_symbol_matcher_spec.rb" with:
-      """
-      describe "throw symbol" do
-        specify { expect { throw :foo    }.to     throw_symbol(:foo) }
-        specify { expect { throw :foo, 7 }.to     throw_symbol(:foo) }
-        specify { expect { 5 + 5         }.to_not throw_symbol(:foo) }
-        specify { expect { throw :bar    }.to_not throw_symbol(:foo) }
-
-        # deliberate failures
-        specify { expect { throw :foo    }.to_not throw_symbol(:foo) }
-        specify { expect { throw :foo, 7 }.to_not throw_symbol(:foo) }
-        specify { expect { 5 + 5         }.to     throw_symbol(:foo) }
-        specify { expect { throw :bar    }.to     throw_symbol(:foo) }
-      end
-      """
-    When I run "rspec throw_symbol_matcher_spec.rb"
-    Then the output should contain all of these:
-      | 8 examples, 4 failures                          |
-      | expected :foo not to be thrown, got :foo        |
-      | expected :foo not to be thrown, got :foo with 7 |
-      | expected :foo to be thrown, got nothing         |
-      | expected :foo to be thrown, got :bar            |
-
-  Scenario: specify thrown symbol and argument
-    Given a file named "throw_symbol_argument_matcher_spec.rb" with:
-      """
-      describe "throw symbol with argument" do
-        specify { expect { throw :foo, 7 }.to     throw_symbol(:foo, 7) }
-        specify { expect { throw :foo, 8 }.to_not throw_symbol(:foo, 7) }
-        specify { expect { throw :bar, 7 }.to_not throw_symbol(:foo, 7) }
-        specify { expect { throw :foo    }.to_not throw_symbol(:foo, 7) }
-
-        # deliberate failures
-        specify { expect { throw :foo, 7 }.to_not throw_symbol(:foo, 7) }
-        specify { expect { throw :foo, 8 }.to     throw_symbol(:foo, 7) }
-        specify { expect { throw :bar, 7 }.to     throw_symbol(:foo, 7) }
-        specify { expect { throw :foo    }.to     throw_symbol(:foo, 7) }
-      end
-      """
-    When I run "rspec throw_symbol_argument_matcher_spec.rb"
-    Then the output should contain all of these:
-      | 8 examples, 4 failures                                       |
-      | expected :foo with 7 not to be thrown, got :foo with 7       |
-      | expected :foo with 7 to be thrown, got :foo with 8           |
-      | expected :foo with 7 to be thrown, got :bar                  |
-      | expected :foo with 7 to be thrown, got :foo with no argument |
-

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

@@ -1,114 +0,0 @@
-Feature: specify types of objects
-
-  rspec-expectations includes two matchers to specify types of objects:
-
-    * obj.should be_kind_of(type): calls obj.kind_of?(type), which returns
-      true if type is in obj's class hierarchy or is a module and is
-      included in a class in obj's class hierarchy.
-    * obj.should be_instance_of(type): calls obj.instance_of?(type), which
-      returns true if and only if type if obj's class.
-
-  Both of these matchers have aliases:
-
-    * obj.should be_a_kind_of(type) # same as obj.should be_kind_of(type)
-    * obj.should be_a(type) # same as obj.should be_kind_of(type)
-    * obj.should be_an(type) # same as obj.should be_kind_of(type)
-    * obj.should be_an_instance_of(type) # same as obj.should be_instance_of(type)
-
-  Scenario: be_(a_)kind_of matcher
-    Given a file named "be_kind_of_matcher_spec.rb" with:
-      """
-      module MyModule; end
-
-      class Fixnum
-        include MyModule
-      end
-
-      describe 17 do
-        # the actual class
-        it { should be_kind_of(Fixnum) }
-        it { should be_a_kind_of(Fixnum) }
-        it { should be_a(Fixnum) }
-
-        # the superclass
-        it { should be_kind_of(Integer) }
-        it { should be_a_kind_of(Integer) }
-        it { should be_an(Integer) }
-
-        # an included module
-        it { should be_kind_of(MyModule) }
-        it { should be_a_kind_of(MyModule) }
-        it { should be_a(MyModule) }
-
-        # negative passing case
-        it { should_not be_kind_of(String) }
-        it { should_not be_a_kind_of(String) }
-        it { should_not be_a(String) }
-
-        # deliberate failures
-        it { should_not be_kind_of(Fixnum) }
-        it { should_not be_a_kind_of(Fixnum) }
-        it { should_not be_a(Fixnum) }
-        it { should_not be_kind_of(Integer) }
-        it { should_not be_a_kind_of(Integer) }
-        it { should_not be_an(Integer) }
-        it { should_not be_kind_of(MyModule) }
-        it { should_not be_a_kind_of(MyModule) }
-        it { should_not be_a(MyModule) }
-        it { should be_kind_of(String) }
-        it { should be_a_kind_of(String) }
-        it { should be_a(String) }
-      end
-      """
-    When I run "rspec be_kind_of_matcher_spec.rb"
-    Then the output should contain all of these:
-      | 24 examples, 12 failures                 |
-      | expected 17 not to be a kind of Fixnum   |
-      | expected 17 not to be a kind of Integer  |
-      | expected 17 not to be a kind of MyModule |
-      | expected 17 to be a kind of String       |
-
-  Scenario: be_(an_)instance_of matcher
-    Given a file named "be_instance_of_matcher_spec.rb" with:
-      """
-      module MyModule; end
-
-      class Fixnum
-        include MyModule
-      end
-
-      describe 17 do
-        # the actual class
-        it { should be_instance_of(Fixnum) }
-        it { should be_an_instance_of(Fixnum) }
-
-        # the superclass
-        it { should_not be_instance_of(Integer) }
-        it { should_not be_an_instance_of(Integer) }
-
-        # an included module
-        it { should_not be_instance_of(MyModule) }
-        it { should_not be_an_instance_of(MyModule) }
-
-        # another class with no relation to the subject's hierarchy
-        it { should_not be_instance_of(String) }
-        it { should_not be_an_instance_of(String) }
-
-        # deliberate failures
-        it { should_not be_instance_of(Fixnum) }
-        it { should_not be_an_instance_of(Fixnum) }
-        it { should be_instance_of(Integer) }
-        it { should be_an_instance_of(Integer) }
-        it { should be_instance_of(MyModule) }
-        it { should be_an_instance_of(MyModule) }
-        it { should be_instance_of(String) }
-        it { should be_an_instance_of(String) }
-      end
-      """
-    When I run "rspec be_instance_of_matcher_spec.rb"
-    Then the output should contain all of these:
-      | 16 examples, 8 failures                     |
-      | expected 17 not to be an instance of Fixnum |
-      | expected 17 to be an instance of Integer    |
-      | expected 17 to be an instance of MyModule   |
-      | expected 17 to be an instance of String     |

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/custom_matchers/access_running_example.feature

@@ -1,53 +0,0 @@
-Feature: access running example
-
-  In order to take advantage of services that are available
-    in my examples when I'm writing matchers
-  As a spec author
-  I want to call methods on the running example
-
-  If the method exists in the context of the example, it gets
-  called. If not, a NoMethodError is raised on the Matcher itself
-  (not the example).
-
-  Scenario: call method defined on example from matcher
-    Given a file named "example_spec.rb" with:
-      """
-      RSpec::Matchers.define :bar do
-        match do |_|
-          foo == "foo"
-        end
-      end
-
-      describe "something" do
-        def foo
-          "foo"
-        end
-
-        it "does something" do
-          "foo".should bar
-        end
-      end
-      """
-    When I run "rspec ./example_spec.rb"
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: call method _not_ defined on example from matcher
-    Given a file named "example_spec.rb" with:
-      """
-      RSpec::Matchers.define :bar do
-        match do |_|
-          foo == "foo"
-        end
-      end
-
-      describe "something" do
-        it "does something" do
-          "foo".should bar
-        end
-      end
-      """
-    When I run "rspec ./example_spec.rb"
-    Then the output should contain "1 example, 1 failure"
-    And the output should contain "undefined local variable"
-    And the output should contain "RSpec::Matchers::Matcher"
-    And the output should not contain "ExampleGroup"

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/custom_matchers/define_diffable_matcher.feature

@@ -1,27 +0,0 @@
-Feature: define diffable matcher
-
-  When a matcher is defined as diffable, and the --diff
-  flag is set, the output will include a diff of the submitted
-  objects.
-
-  @wip
-  Scenario: define a diffable matcher
-    Given a file named "diffable_matcher_spec.rb" with:
-      """
-      RSpec::Matchers.define :be_just_like do |expected|
-        match do |actual|
-          actual == expected
-        end
-        
-        diffable
-      end
-
-      describe "this" do
-        it {should be_just_like("that")}
-      end
-      """
-    When I run "rspec ./diffable_matcher_spec.rb --diff"
-    Then the exit status should not be 0
-
-    And the output should contain "should be just like that"
-    And the output should contain "Diff:\n@@ -1,2 +1,2 @@\n-that\n+this"

data/spec/ruby/1.9.1/gems/rspec-expectations-2.5.0/features/custom_matchers/define_matcher.feature

@@ -1,311 +0,0 @@
-Feature: define matcher
-
-  In order to express my domain clearly in my code examples
-  As an RSpec user
-  I want a shortcut to define custom matchers
-
-  Scenario: define a matcher with default messages
-    Given a file named "matcher_with_default_message_spec.rb" with:
-      """
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-      end
-
-      describe 9 do
-        it {should be_a_multiple_of(3)}
-      end
-
-      describe 9 do
-        it {should_not be_a_multiple_of(4)}
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should be_a_multiple_of(4)}
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should_not be_a_multiple_of(3)}
-      end
-
-      """
-    When I run "rspec ./matcher_with_default_message_spec.rb --format documentation"
-    Then the exit status should not be 0
-
-    And the output should contain "should be a multiple of 3"
-    And the output should contain "should not be a multiple of 4"
-    And the output should contain "Failure/Error: it {should be_a_multiple_of(4)}"
-    And the output should contain "Failure/Error: it {should_not be_a_multiple_of(3)}"
-
-    And the output should contain "4 examples, 2 failures"
-    And the output should contain "expected 9 to be a multiple of 4"
-    And the output should contain "expected 9 not to be a multiple of 3"
-
-  Scenario: overriding the failure_message_for_should
-    Given a file named "matcher_with_failure_message_spec.rb" with:
-      """
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-        failure_message_for_should do |actual|
-          "expected that #{actual} would be a multiple of #{expected}"
-        end
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should be_a_multiple_of(4)}
-      end
-      """
-    When I run "rspec ./matcher_with_failure_message_spec.rb"
-    Then the exit status should not be 0
-    And the stdout should contain "1 example, 1 failure"
-    And the stdout should contain "expected that 9 would be a multiple of 4"
-
-  Scenario: overriding the failure_message_for_should_not
-    Given a file named "matcher_with_failure_for_message_spec.rb" with:
-      """
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-        failure_message_for_should_not do |actual|
-          "expected that #{actual} would not be a multiple of #{expected}"
-        end
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should_not be_a_multiple_of(3)}
-      end
-      """
-    When I run "rspec ./matcher_with_failure_for_message_spec.rb"
-    Then the exit status should not be 0
-    And the stdout should contain "1 example, 1 failure"
-    And the stdout should contain "expected that 9 would not be a multiple of 3"
-
-  Scenario: overriding the description
-    Given a file named "matcher_overriding_description_spec.rb" with:
-      """
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-        description do
-          "be multiple of #{expected}"
-        end
-      end
-
-      describe 9 do
-        it {should be_a_multiple_of(3)}
-      end
-
-      describe 9 do
-        it {should_not be_a_multiple_of(4)}
-      end
-      """
-    When I run "rspec ./matcher_overriding_description_spec.rb --format documentation"
-    Then the exit status should be 0
-    And the stdout should contain "2 examples, 0 failures"
-    And the stdout should contain "should be multiple of 3"
-    And the stdout should contain "should not be multiple of 4"
-
-  Scenario: with no args
-    Given a file named "matcher_with_no_args_spec.rb" with:
-      """
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :have_7_fingers do
-        match do |thing|
-          thing.fingers.length == 7
-        end
-      end
-
-      class Thing
-        def fingers; (1..7).collect {"finger"}; end
-      end
-
-      describe Thing do
-        it {should have_7_fingers}
-      end
-      """
-    When I run "rspec ./matcher_with_no_args_spec.rb --format documentation"
-    Then the exit status should be 0
-    And the stdout should contain "1 example, 0 failures"
-    And the stdout should contain "should have 7 fingers"
-
-  Scenario: with multiple args
-    Given a file named "matcher_with_multiple_args_spec.rb" with:
-      """
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_the_sum_of do |a,b,c,d|
-        match do |sum|
-          a + b + c + d == sum
-        end
-      end
-
-      describe 10 do
-        it {should be_the_sum_of(1,2,3,4)}
-      end
-      """
-    When I run "rspec ./matcher_with_multiple_args_spec.rb --format documentation"
-    Then the exit status should be 0
-    And the stdout should contain "1 example, 0 failures"
-    And the stdout should contain "should be the sum of 1, 2, 3, and 4"
-
-  Scenario: with helper methods
-    Given a file named "matcher_with_internal_helper_spec.rb" with:
-      """
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :have_same_elements_as do |sample|
-        match do |actual|
-          similar?(sample, actual)
-        end
-
-        def similar?(a, b)
-          a.sort == b.sort
-        end
-      end
-
-      describe "these two arrays" do
-        specify "should be similar" do
-          [1,2,3].should have_same_elements_as([2,3,1])
-        end
-      end
-      """
-    When I run "rspec ./matcher_with_internal_helper_spec.rb"
-    Then the exit status should be 0
-    And the stdout should contain "1 example, 0 failures"
-
-  Scenario: scoped in a module
-    Given a file named "scoped_matcher_spec.rb" with:
-      """
-      require 'rspec/expectations'
-
-      module MyHelpers
-        extend RSpec::Matchers::DSL
-
-        matcher :be_just_like do |expected|
-          match {|actual| actual == expected}
-        end
-      end
-
-      describe "group with MyHelpers" do
-        include MyHelpers
-        it "has access to the defined matcher" do
-          5.should be_just_like(5)
-        end
-      end
-
-      describe "group without MyHelpers" do
-        it "does not have access to the defined matcher" do
-          expect do
-            5.should be_just_like(5)
-          end.to raise_exception
-        end
-      end
-      """
-
-    When I run "rspec ./scoped_matcher_spec.rb"
-    Then the stdout should contain "2 examples, 0 failures"
-
-  Scenario: scoped in an example group
-    Given a file named "scoped_matcher_spec.rb" with:
-      """
-      require 'rspec/expectations'
-
-      describe "group with matcher" do
-        matcher :be_just_like do |expected|
-          match {|actual| actual == expected}
-        end
-
-        it "has access to the defined matcher" do
-          5.should be_just_like(5)
-        end
-
-        describe "nested group" do
-          it "has access to the defined matcher" do
-            5.should be_just_like(5)
-          end
-        end
-
-      end
-
-      describe "group without matcher" do
-        it "does not have access to the defined matcher" do
-          expect do
-            5.should be_just_like(5)
-          end.to raise_exception
-        end
-      end
-      """
-
-    When I run "rspec scoped_matcher_spec.rb"
-    Then the output should contain "3 examples, 0 failures"
-
-  Scenario: matcher with separate logic for should and should_not
-    Given a file named "matcher_with_separate_should_not_logic_spec.rb" with:
-      """
-      RSpec::Matchers.define :contain do |*expected|
-        match_for_should do |actual|
-          expected.all? { |e| actual.include?(e) }
-        end
-
-        match_for_should_not do |actual|
-          expected.none? { |e| actual.include?(e) }
-        end
-      end
-
-      describe [1, 2, 3] do
-        it { should contain(1, 2) }
-        it { should_not contain(4, 5, 6) }
-
-        # deliberate failures
-        it { should contain(1, 4) }
-        it { should_not contain(1, 4) }
-      end
-      """
-    When I run "rspec matcher_with_separate_should_not_logic_spec.rb"
-    Then the output should contain all of these:
-      | 4 examples, 2 failures                    |
-      | expected [1, 2, 3] to contain 1 and 4     |
-      | expected [1, 2, 3] not to contain 1 and 4 |
-
-  Scenario: use define_method to create a helper method with access to matcher params
-    Given a file named "define_method_spec.rb" with:
-      """
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        define_method :is_multiple? do |actual|
-          actual % expected == 0
-        end
-        match { |actual| is_multiple?(actual) }
-      end
-
-      describe 9 do
-        it { should be_a_multiple_of(3) }
-        it { should_not be_a_multiple_of(4) }
-
-        # deliberate failures
-        it { should be_a_multiple_of(2) }
-        it { should_not be_a_multiple_of(3) }
-      end
-      """
-    When I run "rspec define_method_spec.rb"
-    Then the output should contain all of these:
-      | 4 examples, 2 failures               |
-      | expected 9 to be a multiple of 2     |
-      | expected 9 not to be a multiple of 3 |