vagrant-unbundled 1.9.5.1 → 1.9.7.1

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/features/built_in_matchers/yield.feature

@@ -1,161 +0,0 @@
-Feature: yield matchers
-
-  There are four related matchers that allow you to specify whether
-  or not a method yields, how many times it yields, whether or not
-  it yields with arguments, and what those arguments are.
-
-    * `yield_control` matches if the method-under-test yields, regardless
-      of whether or not arguments are yielded.
-    * `yield_with_args` matches if the method-under-test yields with
-      arguments. If arguments are provided to this matcher, it will
-      only pass if the actual yielded arguments match the expected ones
-      using `===` or `==`.
-    * `yield_with_no_args` matches if the method-under-test yields with
-      no arguments.
-    * `yield_successive_args` is designed for iterators, and will match
-      if the method-under-test yields the same number of times as arguments
-      passed to this matcher, and all actual yielded arguments match the
-      expected ones using `===` or `==`.
-
-  Note: your expect block _must_ accept an argument that is then passed on to
-  the method-under-test as a block. This acts as a "probe" that allows the matcher
-  to detect whether or not your method yields, and, if so, how many times and what
-  the yielded arguments are.
-
-  Background:
-    Given a file named "my_class.rb" with:
-      """ruby
-      class MyClass
-        def self.yield_once_with(*args)
-          yield *args
-        end
-
-        def self.yield_twice_with(*args)
-          2.times { yield *args }
-        end
-
-        def self.raw_yield
-          yield
-        end
-
-        def self.dont_yield
-        end
-      end
-      """
-
-  Scenario: yield_control matcher
-    Given a file named "yield_control_spec.rb" with:
-      """ruby
-      require './my_class'
-
-      describe "yield_control matcher" do
-        specify { expect { |b| MyClass.yield_once_with(1, &b) }.to yield_control }
-        specify { expect { |b| MyClass.dont_yield(&b) }.not_to yield_control }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.twice }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.exactly(2).times }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.at_least(1) }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.at_most(3).times }
-
-        # deliberate failures
-        specify { expect { |b| MyClass.yield_once_with(1, &b) }.not_to yield_control }
-        specify { expect { |b| MyClass.dont_yield(&b) }.to yield_control }
-        specify { expect { |b| MyClass.yield_once_with(1, &b) }.to yield_control.at_least(2).times }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.twice }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_least(2).times }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_least(1) }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_most(3).times }
-      end
-      """
-    When I run `rspec yield_control_spec.rb`
-    Then the output should contain all of these:
-      | 13 examples, 7 failures                                   |
-      | expected given block to yield control                     |
-      | expected given block not to yield control                 |
-      | expected given block not to yield control at least twice  |
-      | expected given block not to yield control at most 3 times |
-
-  Scenario: yield_with_args matcher
-    Given a file named "yield_with_args_spec.rb" with:
-      """ruby
-      require './my_class'
-
-      describe "yield_with_args matcher" do
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args("foo") }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args(String) }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args(/oo/) }
-
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args("foo", "bar") }
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args(String, String) }
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args(/fo/, /ar/) }
-
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.not_to yield_with_args(17, "baz") }
-
-        # deliberate failures
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args("foo") }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args(String) }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args(/oo/) }
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.not_to yield_with_args("foo", "bar") }
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args(17, "baz") }
-      end
-      """
-    When I run `rspec yield_with_args_spec.rb`
-    Then the output should contain all of these:
-      | 14 examples, 6 failures                                                               |
-      | expected given block not to yield with arguments, but did                             |
-      | expected given block not to yield with arguments, but yielded with expected arguments |
-      | expected given block to yield with arguments, but yielded with unexpected arguments   |
-
-  Scenario: yield_with_no_args matcher
-    Given a file named "yield_with_no_args_spec.rb" with:
-      """ruby
-      require './my_class'
-
-      describe "yield_with_no_args matcher" do
-        specify { expect { |b| MyClass.raw_yield(&b) }.to yield_with_no_args }
-        specify { expect { |b| MyClass.dont_yield(&b) }.not_to yield_with_no_args }
-        specify { expect { |b| MyClass.yield_once_with("a", &b) }.not_to yield_with_no_args }
-
-        # deliberate failures
-        specify { expect { |b| MyClass.raw_yield(&b) }.not_to yield_with_no_args }
-        specify { expect { |b| MyClass.dont_yield(&b) }.to yield_with_no_args }
-        specify { expect { |b| MyClass.yield_once_with("a", &b) }.to yield_with_no_args }
-      end
-      """
-    When I run `rspec yield_with_no_args_spec.rb`
-    Then the output should contain all of these:
-      | 6 examples, 3 failures                                                             |
-      | expected given block not to yield with no arguments, but did                       |
-      | expected given block to yield with no arguments, but did not yield                 |
-      | expected given block to yield with no arguments, but yielded with arguments: ["a"] |
-
-  Scenario: yield_successive_args matcher
-    Given a file named "yield_successive_args_spec.rb" with:
-      """ruby
-      def array
-        [1, 2, 3]
-      end
-
-      def array_of_tuples
-        [[:a, :b], [:c, :d]]
-      end
-
-      describe "yield_successive_args matcher" do
-        specify { expect { |b| array.each(&b) }.to yield_successive_args(1, 2, 3) }
-        specify { expect { |b| array_of_tuples.each(&b) }.to yield_successive_args([:a, :b], [:c, :d]) }
-        specify { expect { |b| array.each(&b) }.to yield_successive_args(Fixnum, Fixnum, Fixnum) }
-        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(1, 2) }
-
-        # deliberate failures
-        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(1, 2, 3) }
-        specify { expect { |b| array_of_tuples.each(&b) }.not_to yield_successive_args([:a, :b], [:c, :d]) }
-        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(Fixnum, Fixnum, Fixnum) }
-        specify { expect { |b| array.each(&b) }.to yield_successive_args(1, 2) }
-      end
-      """
-    When I run `rspec yield_successive_args_spec.rb`
-    Then the output should contain all of these:
-      | 8 examples, 4 failures                                                                             |
-      | expected given block not to yield successively with arguments, but yielded with expected arguments |
-      | expected given block to yield successively with arguments, but yielded with unexpected arguments   |

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/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:
-      """ruby
-      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:
-      """ruby
-      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 match /undefined.*method/
-    And the output should contain "RSpec::Matchers::DSL::Matcher"
-    And the output should not contain "ExampleGroup"

data/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/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:
-      """ruby
-      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/vendor/bundle/ruby/2.4.0/gems/rspec-expectations-2.14.5/features/custom_matchers/define_matcher.feature

@@ -1,368 +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:
-      """ruby
-      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:
-      """ruby
-      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:
-      """ruby
-      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:
-      """ruby
-      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:
-      """ruby
-      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:
-      """ruby
-      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:
-      """ruby
-      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:
-      """ruby
-      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:
-      """ruby
-      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:
-      """ruby
-      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:
-      """ruby
-      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 |
-
-  Scenario: include a module with helper methods in the matcher
-    Given a file named "include_module_spec.rb" with:
-      """ruby
-      module MatcherHelpers
-        def is_multiple?(actual, expected)
-          actual % expected == 0
-        end
-      end
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        include MatcherHelpers
-        match { |actual| is_multiple?(actual, expected) }
-      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 include_module_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 |
-
-  Scenario: matching against a regular expression
-    Given a file named "regular_expression_matcher_spec.rb" with:
-      """ruby
-      # Due to Ruby's method dispatch mechanism, use the `#match_regex` alias
-      # rather than the `#match` matcher when defining custom matchers via the
-      # DSL.
-
-      RSpec::Matchers.define :be_valid_us_zipcode do
-        match do |actual|
-          expect(actual).to match_regex(/\A\d{5}(-\d{4})?\z/)
-        end
-      end
-
-      describe "30316" do
-        it { should be_valid_us_zipcode }
-      end
-
-      describe "30316-0001" do
-        it { should be_valid_us_zipcode }
-      end
-
-      describe "1000-61303" do
-        it { should_not be_valid_us_zipcode }
-      end
-      """
-    When I run `rspec regular_expression_matcher_spec.rb`
-    Then the stdout should contain "3 examples, 0 failures"